Wie kann ich einen Klassennamen in C # aliasisieren, ohne jeder Datei, die die Klasse verwendet, eine Codezeile hinzufügen zu müssen?

Ich möchte einen Alias ​​für einen Klassennamen erstellen. Die folgende Syntax wäre perfekt:

public class LongClassNameOrOneThatContainsVersionsOrDomainSpecificName
{
   ...
}

public class MyName = LongClassNameOrOneThatContainsVersionOrDomainSpecificName;

aber es wird nicht kompiliert.

Beispiel

Hinweis Dieses Beispiel dient nur der Übersichtlichkeit. Versuchen Sie nicht, dieses spezielle Problem zu lösen, indem Sie vorschlagen, das Design des gesamten Systems zu ändern. Das Vorhandensein oder Fehlen dieses Beispiels ändert nichts an der ursprünglichen Frage.

Einige vorhandene Codes hängen vom Vorhandensein einer statischen Klasse ab:

public static class ColorScheme
{
   ...
}

Dieses Farbschema ist das Outlook 2003-Farbschema. Ich möchte ein Outlook 2007-Farbschema einführen und dabei das Outlook 2003-Farbschema beibehalten:

public static class Outlook2003ColorScheme
{
   ...
}

public static class Outlook2007ColorScheme
{
   ...
}

Aber ich bin immer noch mit der Tatsache konfrontiert, dass der Code vom Vorhandensein einer statischen Klasse namens abhängt ColorScheme. Mein erster Gedanke war, eine ColorSchemeKlasse zu erstellen , die ich entweder erben werde Outlook2003oder Outlook2007:

public static class ColorScheme : Outlook2007ColorScheme
{
}

Sie können jedoch nicht von einer statischen Klasse erben.

Mein nächster Gedanke war, die statische ColorSchemeKlasse zu erstellen , aber make Outlook2003ColorSchemeund Outlook2007ColorSchemeKlassen nicht statisch. Dann kann eine statische Variable in der statischen ColorSchemeKlasse auf eines der "echten" Farbschemata verweisen:

public static class ColorScheme
{
    private static CustomColorScheme = new Outlook2007ColorScheme();
    ...
}

private class CustomColorScheme 
{ 
   ...
}

private class Outlook2008ColorScheme : CustomColorScheme 
{
    ...
}

private class Outlook2003ColorScheme : CustomColorScheme 
{
   ...
}

Dafür müsste ich jedoch eine Klasse konvertieren, die vollständig aus schreibgeschützten statischen Farben besteht, in überschreibbare Eigenschaften, und dann ColorSchememüsste meine Klasse die 30 verschiedenen Eigenschafts-Getter in das enthaltene Objekt einbinden .

Das ist einfach zu viel Tippen.

Mein nächster Gedanke war also, die Klasse zu aliasen:

public static ColorScheme = Outlook2007ColorScheme;

Das lässt sich aber nicht kompilieren.

Wie kann ich eine statische Klasse in einen anderen Namen aliasen?

Update: Kann jemand bitte die Antwort "Sie können dies nicht in C # tun" hinzufügen , damit ich dies als akzeptierte Antwort markieren kann. Jeder andere, der die Antwort auf dieselbe Frage wünscht, findet diese Frage, die akzeptierte Antwort und eine Reihe von Problemumgehungen, die nützlich sein können oder nicht.

Ich möchte diese Frage nur abschließen.

Das kannst du nicht . Das nächstbeste, was Sie tun können , ist, usingDeklarationen in den Dateien zu haben, die die Klasse verwenden.

Sie können beispielsweise den abhängigen Code mithilfe eines Importalias (als Quasi- typedefErsatz) neu schreiben :

using ColorScheme = The.Fully.Qualified.Namespace.Outlook2007ColorScheme;

Leider muss dies in jeden Bereich / jede Datei gehen, die den Namen verwendet.

Ich weiß daher nicht, ob dies in Ihrem Fall praktisch ist.

Sie können einen Alias ​​für Ihre Klasse erstellen, indem Sie folgende Codezeile hinzufügen:

using Outlook2007ColorScheme = YourNameSpace.ColorScheme;

Sie können einen Klassennamen in C # nicht wirklich als Alias ​​verwenden. Sie können eine Problemumgehung mit der Verwendung üben, wie in anderen Antworten erläutert.

Es gibt Dinge, die Sie tun können, ohne einen Klassennamen in C # zu aliasen.

Um die ursprüngliche Frage zu beantworten: Sie können einen Klassennamen in C # nicht als Alias ​​verwenden.

Update: Die Leute sind verwirrt, warum usinges nicht funktioniert. Beispiel:

Form1.cs

private void button1_Click(object sender, EventArgs e)
{
   this.BackColor = ColorScheme.ApplyColorScheme(this.BackColor);
}

ColorScheme.cs

class ColorScheme
{
    public static Color ApplyColorScheme(Color c) { ... }
}

Und alles funktioniert. Jetzt möchte ich eine neue Klasse und einen Alias dafür erstellen ColorScheme(damit kein Code geändert werden muss ):

ColorScheme.cs

using ColorScheme = Outlook2007ColorScheme;

class Outlook2007ColorScheme
{
    public static Color ApplyColorScheme(Color c) { ... }
}

Ohh, es tut mir leid. Dieser Code wird nicht kompiliert:

Meine Frage war , wie man alias eine Klasse in C #. Es kann nicht gemacht werden. Es gibt Dinge, die ich tun kann, die einen Klassennamen in C # nicht aliasen:

• Änderung jeder, hängt davon ab , ColorSchemean using ColorSchemestatt (Codeänderung Abhilfe , weil ich kann nicht Alias)
• Ändern Sie jeden, der darauf angewiesen ist ColorScheme, ein Factory-Muster zu verwenden, in eine polymorphe Klasse oder Schnittstelle (Problemumgehung für Codeänderungen, da ich keinen Alias ​​erstellen kann).

Bei diesen Problemumgehungen wird jedoch vorhandener Code beschädigt: keine Option.

Wenn Leute von der Anwesenheit einer ColorSchemeKlasse abhängig sind , muss ich tatsächlich eine ColorSchemeKlasse kopieren / einfügen .

Mit anderen Worten: Ich kann keinen Klassennamen in C # aliasen.

Dies steht im Gegensatz zu anderen objektorientierten Sprachen, in denen ich den Alias ​​definieren könnte:

ColorScheme = Outlook2007ColorScheme

und ich wäre fertig.

Sie möchten einen ( Factory | Singleton ), abhängig von Ihren Anforderungen. Die Voraussetzung ist, dass der Client-Code nicht wissen muss, welches Farbschema er erhält. Wenn das Farbschema anwendungsweit sein soll, sollte ein Singleton in Ordnung sein. Wenn Sie unter verschiedenen Umständen ein anderes Schema verwenden, ist wahrscheinlich ein Factory-Muster der richtige Weg. In beiden Fällen muss der Code nur an einer Stelle geändert werden, wenn sich das Farbschema ändern muss.

public interface ColorScheme {
    Color TitleBar { get; }
    Color Background{ get; }
    ...
}

public static class ColorSchemeFactory {

    private static ColorScheme scheme = new Outlook2007ColorScheme();

    public static ColorScheme GetColorScheme() { //Add applicable arguments
        return scheme;
    }
}

public class Outlook2003ColorScheme: ColorScheme {
   public Color TitleBar {
       get { return Color.LightBlue; }
   }

    public Color Background {
        get { return Color.Gray; }
    }
}

public class Outlook2007ColorScheme: ColorScheme {
   public Color TitleBar {
       get { return Color.Blue; }
   }

    public Color Background {
        get { return Color.White; }
    }
}

Versuche dies:

using ColorScheme=[fully qualified].Outlook2007ColorScheme

Ich füge diesen Kommentar für Benutzer hinzu, die dies finden, lange nachdem OP ihre "Antwort" akzeptiert hat. Das Aliasing in C # funktioniert durch Angabe des Klassennamens unter Verwendung des vollständig qualifizierten Namespace. Einer der definierten Aliasnamen kann innerhalb seines Gültigkeitsbereichs verwendet werden. Beispiel.

using aliasClass = Fully.Qualified.Namespace.Example;
//Example being the class in the Fully.Qualified.Namespace

public class Test{

  public void Test_Function(){

    aliasClass.DoStuff();
    //aliasClass here representing the Example class thus aliasing
    //aliasClass will be in scope for all code in my Test.cs file
  }

}

Entschuldigung für den schnell eingegebenen Code, aber hoffentlich wird erklärt, wie dies implementiert werden sollte, damit Benutzer nicht irreführen, zu glauben, dass dies in C # nicht möglich ist.

Das Aliasing der Art und Weise, wie Sie es tun möchten, funktioniert in C # nicht. Dies liegt daran, dass das Aliasing über das erfolgtusing Direktive erfolgt, die auf die betreffende Datei / den betreffenden Namespace beschränkt ist. Wenn Sie 50 Dateien haben, die den alten Klassennamen verwenden, bedeutet dies, dass 50 Stellen aktualisiert werden müssen.

Trotzdem denke ich, dass es eine einfache Lösung gibt, um Ihre Codeänderung so gering wie möglich zu halten. Machen Sie die ColorSchemeKlasse zu einer Fassade für Ihre Aufrufe der tatsächlichen Klassen mit der Implementierung und verwenden Sie die usingin dieser Datei, um zu bestimmen, welche ColorSchemeSie verwenden.

Mit anderen Worten, tun Sie dies:

using CurrentColorScheme = Outlook2007ColorScheme;
public static class ColorScheme
{
   public static Color ApplyColorScheme(Color c)
   {
       return CurrentColorScheme.ApplyColorScheme(c);
   }
   public static Something DoSomethingElse(Param a, Param b)
   {
       return CurrentColorScheme.DoSomethingElse(a, b);
   }
}

Dann ändern Sie in Ihrem Code dahinter nichts:

private void button1_Click(object sender, EventArgs e)
{
   this.BackColor = ColorScheme.ApplyColorScheme(this.BackColor);
}

Sie können dann die Werte ColorSchemevon aktualisieren, indem Sie eine Codezeile aktualisieren (using CurrentColorScheme = Outlook2008ColorScheme; ) .

Ein paar Bedenken hier:

• Jede neue Methode oder Eigenschaftsdefinition muss dann an zwei Stellen hinzugefügt werden, zur ColorSchemeKlasse und zur Outlook2007ColorSchemeKlasse. Dies ist zusätzliche Arbeit, aber wenn es sich um echten Legacy-Code handelt, sollte dies nicht häufig vorkommen. Als Bonus wird der Code inColorScheme so einfach, dass jeder mögliche Fehler sehr offensichtlich ist.
• Diese Verwendung statischer Klassen erscheint mir nicht selbstverständlich. Ich würde wahrscheinlich versuchen, den Legacy-Code zu überarbeiten, um dies anders zu machen, aber ich verstehe auch, dass Ihre Situation dies möglicherweise nicht zulässt.
• Wenn Sie bereits eine ColorSchemeKlasse haben, die Sie ersetzen, können dieser und alle anderen Ansätze ein Problem darstellen. Ich würde empfehlen, dass Sie diese Klasse in etwas umbenennen ColorSchemeOldund dann über darauf zugreifen using CurrentColorScheme = ColorSchemeOld;.

Ich nehme an, Sie können immer von der Basisklasse erben, ohne dass etwas hinzugefügt wird

public class Child : MyReallyReallyLongNamedClass {}

AKTUALISIEREN

Aber wenn Sie die Möglichkeit haben, sich classselbst umzugestalten : Ein Klassenname ist normalerweise unnötig lang, da namespaces fehlt .

Wenn Sie sehen , wie Fälle ApiLoginUser, DataBaseUser,WebPortalLoginUser , ist in der Regel Hinweis auf fehlende namespacewegen der Furcht , dass der Name Userkönnte Konflikt.

In diesem Fall können Sie jedoch einen namespaceAlias ​​verwenden , wie in den obigen Beiträgen erwähnt

using LoginApi = MyCompany.Api.Login;
using AuthDB = MyCompany.DataBase.Auth;
using ViewModels = MyCompany.BananasPortal.Models;

// ...
AuthDB.User dbUser;
using ( var ctxt = new AuthDB.AuthContext() )
{
    dbUser = ctxt.Users.Find(userId);
}

var apiUser = new LoginApi.Models.User {
        Username = dbUser.EmailAddess,
        Password = "*****"
    };

LoginApi.UserSession apiUserSession = await LoginApi.Login(apiUser);
var vm = new ViewModels.User(apiUserSession.User.Details);
return View(vm);

Beachten Sie, wie die classNamen alle sind User, aber in verschiedenen namespaces. Zitieren PEP-20: Zen of Python :

Namespaces sind eine großartige Idee - lasst uns mehr davon machen!

Hoffe das hilft

Ist es möglich, auf eine Schnittstelle umzusteigen?

Vielleicht könnten Sie eine IColorSchemeSchnittstelle erstellen , die alle Klassen implementieren?

Dies würde gut mit dem Fabrikmuster funktionieren, wie es von Chris Marasti-Georg gezeigt wird

Es ist eine sehr späte Teilantwort. Wenn Sie jedoch dieselbe Klasse 'ColorScheme' im selben Namespace 'Outlook' definieren, jedoch in separaten Assemblys, eine mit dem Namen Outlook2003 und die andere mit Outlook2007, müssen Sie nur auf die entsprechende Assembly verweisen .

Während die von Ihnen angeforderte Funktionalität nicht vorhanden ist und meine Antwort Ihre Frage per se nicht beantwortet, ist es möglich, die ColorScheme-Klasse intakt zu lassen und mit Veraltet zu markieren Attribut und dann die beiden anderen neuen Farbschema-Klassen hinzuzufügen.

Dies würde keine systemischen Änderungen erfordern und hält die veraltete Klasse isoliert.