Como faço para criar um alias para um nome de classe em C #, sem precisar adicionar uma linha de código a cada arquivo que usa a classe?

Quero criar um alias para o nome de uma classe. A seguinte sintaxe seria perfeita:

public class LongClassNameOrOneThatContainsVersionsOrDomainSpecificName
{
   ...
}

public class MyName = LongClassNameOrOneThatContainsVersionOrDomainSpecificName;

mas não compilará.

Exemplo

Nota Este exemplo é fornecido apenas por conveniência. Não tente resolver esse problema específico sugerindo alterar o design de todo o sistema. A presença, ou falta, deste exemplo não altera a pergunta original.

Alguns códigos existentes dependem da presença de uma classe estática:

public static class ColorScheme
{
   ...
}

Este esquema de cores é o esquema de cores do Outlook 2003. quero apresentar um esquema de cores do Outlook 2007, mantendo o esquema de cores do Outlook 2003:

public static class Outlook2003ColorScheme
{
   ...
}

public static class Outlook2007ColorScheme
{
   ...
}

Mas ainda sou confrontado com o fato de que o código depende da presença de uma classe estática chamada ColorScheme. Meu primeiro pensamento foi criar uma ColorSchemeclasse que herdarei de Outlook2003ou Outlook2007:

public static class ColorScheme : Outlook2007ColorScheme
{
}

mas você não pode herdar de uma classe estática.

Meu próximo pensamento foi criar a ColorSchemeclasse estática , mas fazer Outlook2003ColorSchemee as Outlook2007ColorSchemeclasses não estáticas. Então, uma variável estática na ColorSchemeclasse estática pode apontar para qualquer esquema de cores "verdadeiro":

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

private class CustomColorScheme 
{ 
   ...
}

private class Outlook2008ColorScheme : CustomColorScheme 
{
    ...
}

private class Outlook2003ColorScheme : CustomColorScheme 
{
   ...
}

mas isso exigiria que eu convertesse uma classe composta inteiramente de cores estáticas somente leitura em propriedades substituíveis e, em seguida, minha ColorSchemeclasse precisaria ter os 30 getters de propriedade diferentes transformados no objeto contido.

Isso é muita digitação.

Então, meu próximo pensamento foi criar um alias para a classe:

public static ColorScheme = Outlook2007ColorScheme;

Mas isso não compila.

Como posso criar um alias para uma classe estática com outro nome?

Atualização: Alguém pode adicionar a resposta "Você não pode fazer isso em C #" , para que eu possa marcá-la como uma resposta aceita. Qualquer pessoa que deseje a resposta para a mesma pergunta encontrará esta pergunta, a resposta aceita e uma série de soluções alternativas que podem ou não ser úteis.

Eu só quero encerrar esta questão.

Você não pode . A próxima melhor coisa que você pode fazer é ter usingdeclarações nos arquivos que usam a classe.

Por exemplo, você pode reescrever o código dependente usando um alias de importação (como um quase typedefsubstituto):

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

Infelizmente, isso precisa entrar em cada escopo / arquivo que usa o nome.

Portanto, não sei se isso é prático no seu caso.

Você pode criar um alias para sua classe adicionando esta linha de código:

using Outlook2007ColorScheme = YourNameSpace.ColorScheme;

Você deseja um ( Factory | Singleton ), dependendo de seus requisitos. A premissa é fazer com que o código do cliente não precise saber qual esquema de cores está recebendo. Se o esquema de cores deve ser amplo, um singleton deve servir. Se você pode usar um esquema diferente em circunstâncias diferentes, um padrão de fábrica é provavelmente o caminho a percorrer. De qualquer forma, quando o esquema de cores precisa ser alterado, o código só precisa ser alterado em um lugar.

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; }
    }
}

Você não pode criar um alias para um nome de classe em C #.

Existem coisas que você pode fazer que não são o alias de um nome de classe em C #.

Mas, para responder à pergunta original: você não pode criar um alias para um nome de classe em C #.

Update: As pessoas estão confusas porque usingnão funciona. Exemplo:

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) { ... }
}

E tudo funciona. Agora eu quero criar uma nova classe e um alias ColorScheme para ela (de modo que nenhum código precise ser modificado ):

ColorScheme.cs

using ColorScheme = Outlook2007ColorScheme;

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

Ohh, sinto muito. Este código não compila:

Minha pergunta era como criar um alias para uma classe em C #. Isso não pode ser feito. Existem coisas que posso fazer que não são o alias de um nome de classe em C #:

• altere todos os que dependem ColorSchemepara using ColorScheme(solução alternativa de alteração de código porque não consigo apelido)
• mude todos os que dependem ColorSchemepara usar um padrão de fábrica para uma classe polimórfica ou interface (solução alternativa de mudança de código porque eu não consigo apelido)

Mas essas soluções alternativas envolvem quebrar o código existente: não é uma opção.

Se as pessoas dependem da presença de uma ColorSchemeclasse, tenho que realmente copiar / colar uma ColorSchemeclasse.

Em outras palavras: não posso criar um alias para o nome de uma classe em C #.

Isso contrasta com outras linguagens orientadas a objetos, onde eu poderia definir o alias:

ColorScheme = Outlook2007ColorScheme

e eu estaria pronto.

tente isto:

using ColorScheme=[fully qualified].Outlook2007ColorScheme

Estou adicionando este comentário para usuários que acham isso muito depois de OP aceitar sua "resposta". Aliasing em C # funciona especificando o nome da classe usando seu namespace totalmente qualificado. Um definido, o nome do alias pode ser usado dentro de seu escopo. Exemplo.

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
  }

}

Pedimos desculpas pelo código digitado rapidamente, mas espero que ele explique como isso deve ser implementado para que os usuários não se enganem pensando que isso não pode ser feito em C #.

Criar apelidos da maneira que você gostaria de fazer não funcionará em C #. Isso ocorre porque o aliasing é feito por meio da usingdiretiva, que é limitada ao arquivo / espaço de nomes em questão. Se você tiver 50 arquivos que usam o nome da classe antiga, isso significará 50 lugares para atualizar.

Dito isso, acho que há uma solução fácil para fazer a alteração do código o mínimo possível. Faça da ColorSchemeclasse uma fachada para suas chamadas para as classes reais com a implementação e use o usingnesse arquivo para determinar qual ColorSchemevocê usa.

Em outras palavras, faça o seguinte:

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);
   }
}

Então, em seu code-behind, não mude nada:

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

Você pode então atualizar os valores de ColorSchemeatualizando uma linha de código ( using CurrentColorScheme = Outlook2008ColorScheme;).

Algumas preocupações aqui:

• Cada novo método ou definição de propriedade precisará então ser adicionado em dois lugares, para a ColorSchemeclasse e para a Outlook2007ColorSchemeclasse. Isso é um trabalho extra, mas se for um código legado verdadeiro, não deve ser uma ocorrência frequente. Como um bônus, o código ColorSchemeé tão simples que qualquer bug possível é muito óbvio.
• Esse uso de classes estáticas não parece natural para mim; Eu provavelmente tentaria refatorar o código legado para fazer isso de maneira diferente, mas também entendo que sua situação pode não permitir isso.
• Se você já tem uma ColorSchemeclasse que está substituindo, esta abordagem e qualquer outra pode ser um problema. Aconselho que você renomeie essa classe para algo como ColorSchemeOlde, em seguida, acesse-a por meio de using CurrentColorScheme = ColorSchemeOld;.

Suponho que você sempre pode herdar da classe base sem adicionar nada

public class Child : MyReallyReallyLongNamedClass {}

ATUALIZAR

Mas se você tiver a capacidade de refatorar o classpróprio: Um nome de classe geralmente é desnecessariamente longo devido à falta de namespaces.

Se você vê casos como ApiLoginUser, DataBaseUser, WebPortalLoginUser, é geralmente indicação de falta de namespacedevido o medo de que o nome Userconflito força.

Neste caso, entretanto, você pode usar um namespaceapelido , como foi apontado nas postagens acima

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);

Observe como os classnomes são todos User, mas em namespaces diferentes . Citando PEP-20: Zen de Python :

Os namespaces são uma ótima ideia - vamos fazer mais disso!

Espero que isto ajude

É possível mudar para uma interface?

Talvez você possa criar uma IColorSchemeinterface que todas as classes implementem?

Isso funcionaria bem com o padrão de fábrica mostrado por Chris Marasti-Georg

É uma resposta parcial muito tardia - mas se você definir a mesma classe 'ColorScheme', no mesmo namespace 'Outlook', mas em assemblies separados, um chamado Outlook2003 e o outro Outlook2007, então tudo que você precisa fazer é referenciar o assembly apropriado .