Curso de C#: Lição 19: Encapsulamento

Esta lição vai discutir com os seguintes objectivos: Compreender o objeto-orientado princípio de encapsulação. Aprenda os modificadores disponíveis para os membros tipo. Proteja objeto Estado, através propriedades. Controlar o acesso aos métodos. Saiba como modificar tipos de montagem encapsulamento

Por | @oficinadanet Programação
Anteriores deste tutorial, você aprendeu sobre a importância de dois princípios de programação orientada para objetos, Herança e Polimorfismo. Agora que você já viu muita da sintaxe do C #, eu vou mostrar-lhe como C # suporta o outro do objeto - princípios orientado - Encapsulamento. Esta lição vai discutir com os seguintes objectivos:
  • Compreender o objeto-orientado princípio de encapsulação.
  • Aprenda os modificadores disponíveis para os membros tipo.
  • Proteja objeto Estado, através propriedades.
  • Controlar o acesso aos métodos.
  • Saiba como modificar tipos de montagem encapsulamento


O que é o encapsulamento e como é que ela me beneficiar?


Na programação orientada para objeto, você cria objetos que têm estado e comportamento. Um objeto do estado é o dado ou informação que ele contém. Por exemplo, se você tiver um bankaccount objeto, o seu estado poderia ser Montante e CustomerName. Comportamento em um objeto é muitas vezes representado por métodos. Por exemplo, o objeto da bankaccount comportamento poderia ser de crédito, débito, e GetAmount. Isto soa como uma bela definição de um objeto, e é, mas também é necessário reflectir sobre o modo como esse objeto será usado.

Ao conceber um objeto, você deve pensar em como as outras pessoas poderão usá-lo. Na melhor das hipóteses qualquer programa usando o objeto seria bem concebido e nunca iria alterar o código. No entanto, a realidade é que muitas vezes programas e fazer mudanças em um ambiente equipe muita gente tocar o mesmo código em uma hora ou outra. Portanto, é benéfico para considerar o que poderia dar errado, assim como a imagem do primitivo como o objeto * deve * ser utilizado.

No caso do objeto bankaccount, analisar a situação em que fora de seu código objeto poderá acessar um decimal campo ou uma seqüência CustomerName campo. No ponto de tempo em que o código está escrito, tudo iria funcionar bem. Porém, mais tarde, no desenvolvimento do ciclo, você percebe que o objeto bankaccount deve manter controle de uma string em vez de int CustomerID CustomerName porque não pretende duplicar as relações entre informação (ou alguma outra razão válida para alterar a definição do estado interno). Essas mudanças provocam um onduladas efeito no seu código, porque foi construída para usar o bankaccount classe, como originalmente concebida (com CustomerName sendo uma string), e agora você deve alterar o código que acessa esse estado em toda a sua aplicação.

O objeto-orientado princípio da Encapsulation ajuda a evitar tais problemas, o que lhe permite esconder estado interno e acesso ao resumo embora ele escreva membros, como métodos, propriedades e indexadores. Encapsulamento ajuda a reduzir acoplamento entre objetos e aumenta a durabilidade do seu código.

Tipo Acess Modifier


Um acesso modificador permite que você especifique a visibilidade do código fora de um tipo ou de montagem. Acesso modificadores podem ser aplicados a qualquer tipo ou tipos de membros. A secção posterior sobre Tipo Modificadores acesso discute modificadores que podem ser aplicados aos tipos. Esta seção discute os modificadores que se aplicam ao tipo membros e como eles afetam visibilidade.

Geralmente, você deve esconder o estado interno de seu objeto de código de acesso directo do exterior. Em seguida, executar outros membros, como os métodos e propriedades, que vestiram esse estado. Isto permite a implementação interna do Estado para alterar a vontade de cada um, enquanto os membros embalar o estado ainda pode retornar uma representação do Estado que não mude. Isto significa que, fora Código irá aceder ao seu objeto através de membros que vestiram estado e que seja garantido o tipo de informação extraída é coerente. Adicionalmente, por causa externa código não tem acesso ao estado interno de seu objeto, eles não podem alterar esse estado inconsistente em uma maneira que possa quebrar a forma como as suas obras objeto.

O primeiro passo para o encapsulamento estado é objeto de determinar que tipo de acesso que o código externo deve ter como aos membros do seu tipo. Esta é realizada com acesso modificadores. O tipo de acesso concedido varia de nenhum acesso externo a todos os cidadãos para o pleno acesso e algumas variações de entre os extremos. Tabela 19-1 enumera todos os tipos de membro acesso modificadores e explica seu significado.

Tabela 19-1.Tipo de membro acesso modificadores código controlar o que tem acesso a um determinado tipo de membro.
Curso de C#: Lição 19: Encapsulamento

Como você anteriores lições aprendidas a partir do C # Tutorial, tipos contêm vários tipos de membros, incluindo construtores, propriedades, indexadores, métodos, e outros. Ao invés de te mostrar uma lista exaustiva de todas as permutações de acesso modificadores que você pode usar com estes membros, eu vou ter uma abordagem mais prática e descrevem um sub-conjunto de acesso modificadores utilizados em propriedades e métodos.

Tipos escondidos com acesso público


Você já viu o acesso público modificador utilizado em peças anteriores do C # Tutorial. Qualquer hora do acesso público modificador é utilizado um tipo de membro, chamando código será capaz de acessar o membro tipo. Se você fizer o seu tipo de membro público, você todos estão dando permissão para usá-lo.

Listing 19-1 mostra um exemplo de como usar o acesso do público sobre um método modificador.
 using System;

class BankAccountPublic
{
    public decimal GetAmount()
    {
        return 1000.00m;
    }
}


O GetAmount () na listagem 19-1 método é público o que significa que ele pode ser chamado pelo código que é externa para esta classe. Agora, você pode escrever o seguinte código, em qualquer outra parte do seu programa, para usar este método

BankAccountPublic bankAcctPub = new BankAccountPublic();

// call a public method
decimal amount = bankAcctPub.GetAmount();


Tudo que você precisa fazer, como acima demonstrado, é criar uma instância da classe que contém o método e, em seguida, chame o método através desse exemplo. Porque é público, não terá um problema. Remember that the default access for a type member is private , which we'll talk about next.  Lembre-se que o padrão de acesso para um tipo de membro é privado, que nós vamos falar sobre outra. Isto significa que se você esquecer o público modificador, e não usar nenhum modificador de todo, que receberia um compilador erro.

Tipo escondido com acesso privado


Um membro privado é um tipo que só pode ser acessado por membros de um mesmo tipo. Por exemplo, se o bankaccount classe tem um membro privado, apenas os outros membros da classe bankaccount pode acessar ou ligar para esse membro.

Embora o padrão de acesso para os membros tipo é privado, eu prefiro ser explícito sobre as minhas intenções quando declara tipo membros e incluir o acesso modificador, em vez de depender das faltas. Eu acho que ela torna o código mais fácil de ler e deixa claro a outros desenvolvedores o que a minha intenção é verdade.

Listando 19-2 mostra como usar o modificador acesso privado e oferece um exemplo de por que você iria querer usá-lo.

 using System;

class BankAccountPrivate
{
    private string m_name;

    public string CustomerName
    {
        get { return m_name; }
        set { m_name = value; }
    }
}


É comum para encapsular o estado do seu tipo com propriedades. Na verdade, eu me vestiram tipo estado em um imóvel. Listing Em 19-2, você pode ver como o nome do cliente é realizada no m_name campo, mas é acondicionada (encapsulados) com o CustomerName propriedade. Porque m_name é declarado como privado, o código fora BankAccountPrivate classe não pode acessá-lo diretamente. Eles devem usar a propriedade pública CustomerName vez.

Agora você pode alterar a implementação de m_name de qualquer forma que quiser. Por exemplo, se o que você queria que fosse uma identificação do tipo int e à propriedade CustomerName faria uma busca para encontrar o nome ou o que se pretendia ter em primeiro lugar e sobrenome CustomerName valores que a propriedade poderia concatenar. Há todo tipo de coisas a acontecer com o seu código de manutenção que irá causar a execução mudança. O ponto é que os membros privados permitem a implementação de mudanças sem constranger a execução ou onduladas causando efeitos em todo o seu código base que teria ocorrido se o código externo teve acesso aos membros do seu tipo.

O acesso público e privado em modificadores são os dois extremos do acesso, quer todas as negando o acesso externo ou permitindo que todos os acessos exteriores, respectivamente. Os outros são como acesso modificadores diferentes tons de cinza entre estes dois extremos, incluindo a protegida modificador, discutidos a seguir.

Acesso com o tipo protegido por Modificador (modifier)


De certa forma, o acesso protegido atua como modificador tanto o acesso público e privado modificadores. Tal como privado, que só permite o acesso a membros de um mesmo tipo, exceto que ele age como público apenas aos tipos de derivados. De outra forma, protegido tipo membros só pode ser acessado por membros, quer dentro do mesmo tipo ou de membros de tipos derivados.

Voltando ao exemplo bankaccount, o que acontece se você chamar código necessário para fechar a conta? Além disso, que se houvesse diferentes tipos de contas? Cada um destes diferentes tipos teria em conta a sua própria lógica de fechamento, mas o processo básico seria o mesmo para todos os tipos de conta. Se isso soa para você como a descrição de Polimorfismo, você estaria no caminho certo. Voltar a Lição 9, discutimos polimorfismo e como ela nos permite tratar diferentes classes da mesma maneira. Você pode querer remetem para Lição 9 para uma refeição leve antes de olhar para o próximo exemplo.

No caso de encerramento de uma conta, há várias coisas que precisam ser feitas como calcular os juros que são devidos, aplicando sanções em caso de rescisão antecipada, e fazendo o trabalho para remover a conta a partir da base de dados. Individualmente, você não quer nenhum código para chamar métodos da classe a não ser que todos bankaccount dos métodos são chamados e cada método é chamado na ordem correta. Por exemplo, que se algum código chamado o método para apagar a conta do banco de dados e não calcular juros ou aplicar sanções? Alguém teria solto dinheiro. Além disso, se o código foi chamada para apagar a primeira conta, em seguida, os outros métodos não incorrer em erros porque as informações da conta não está disponível. Portanto, você precisa para controlar esta situação e Listagem 19 -- 3 mostra como você pode fazê-lo.

Listando 19-3. Declarando Métodos protegidos: BankAccountProtected.cs
 using System;

class BankAccountProtected
{
    public void CloseAccount()
    {
        ApplyPenalties();
        CalculateFinalInterest();
        DeleteAccountFromDB();
    }

    protected virtual void ApplyPenalties()
    {
        // deduct from account
    }

    protected virtual void CalculateFinalInterest()
    {
        // add to account
    }

    protected virtual void DeleteAccountFromDB()
    {
        // send notification to data entry personnel
    }
}


As peças mais importantes da listagem 19-3 são CloseAccount método é que o público e os outros métodos são protegidos. Qualquer código pode criar uma instância chamada BankAccountProtected, mas ela só pode chamar o método CloseAccount. Isto dá-lhe protecção de alguém que invoque o comportamento do seu objeto em formas inadequadas. Seu negócio é uma boa lógica.

Ao final desta seção, você verá um exemplo de como chamar o código na listagem 19-3. Por agora, é essencial que você veja como as outras peças se articulam em primeiro lugar.

Se você só queria o BankAccountProtected classe para operar em seus próprios membros, você poderia ter feito os métodos privados em lugar protegido. Contudo, este código apoia um quadro onde se pode ter em conta diferentes tipos, como a Caixa Econômica, Verificação e muito mais. Você será capaz de adicionar novos tipos de conta no futuro, porque a classe BankAccountProtected destina-se a apoiá-las protegidas com métodos virtuais. Listagens 19-4 e 19-5 e mostrar-lhe o SavingsAccount CheckingAccount classes que derivam da classe BankAccountProtected.

Listando 19-4. Usando classe derivada SavingsAccount protegido. SavingsAccount.cs
 using System;

class SavingsAccount : BankAccountProtected
{
    protected override void ApplyPenalties()
    {
        Console.WriteLine("Savings Account Applying Penalties");
    }

    protected override void CalculateFinalInterest()
    {
        Console.WriteLine("Savings Account Calculating Final Interest");
    }

    protected override void DeleteAccountFromDB()
    {
        base.DeleteAccountFromDB();
        Console.WriteLine("Savings Account Deleting Account from DB");
    }
}


Observe como SavingsAccount deriva BankAccountProtected. SavingsAccount pode acessar qualquer um dos membros da protegidas BankAccountProtected classe que é a sua classe base. Demonstra este facto através da chamada para base.DeleteAccountFromDB em que é DeleteAccountFromDB método. Se a herança parte da listagem 19-4 é um pouco confusa, você pode visitar Lição 8: classe Herança e de refrescamento para uma melhor compreensão. Cada método de SavingsAccount tem também o acesso protegido modificador, que significa simplesmente que classes derivadas de SavingsAccount pode acessar esses SavingsAccount membros, com o acesso protegido modificador. A mesma situação existe com o CheckingAccount classe, mostrado na listagem 19-5.

Listando 19-5. Usando classe derivada CheckingAccount protegida. CheckingAccount.cs
 using System;

class CheckingAccount : BankAccountProtected
{
    protected override void ApplyPenalties()
    {
        Console.WriteLine("Checking Account Applying Penalties");
    }

    protected override void CalculateFinalInterest()
    {
        Console.WriteLine("Checking Account Calculating Final Interest");
    }

    protected override void DeleteAccountFromDB()
    {
        base.DeleteAccountFromDB();
        Console.WriteLine("Checking Account Deleting Account from DB");
    }
}


A classe em CheckingAccount Listing 19-5 é semelhante ao aplicado a partir de SavingsAccount Listing 19-6. Se você estava escrevendo isto, a diferença seria que os métodos de cada classe teria únicas implementações. Por exemplo, as regras comerciais associados ao final cálculo juros seriam diferentes, dependendo se estava verificando o tipo de conta ou poupança.

Aviso a chamada para a classe base no método DeleteAccountFromlDB método em CheckingAccount. Exatamente como SavingsAccount, CheckingAccount tem acesso a BankAccountProtected está protegido porque é um método de classe derivada. Este é um padrão comum nas classes derivadas polimorfismo porque muitas vezes têm a responsabilidade de chamar classe base virtual métodos para garantir a funcionalidade crítica tem a oportunidade de executar. Você iria consultar o método documentação para ver se isso era necessário. Sem um acesso protegido modificador, sua única opção teria sido a de tornar público o método de classe base, o que, como explicado anteriormente, é perigoso.

Para usar o código a partir de listagens 19-3, 19-4 e 19-5, você pode executar o seguinte código:
 BankAccountProtected[] bankAccts = new BankAccountProtected[2];
bankAccts[0] = new SavingsAccount();
bankAccts[1] = new CheckingAccount();

foreach (BankAccountProtected acct in bankAccts)
{
    // call public method, which invokes protected virtual methods
    acct.CloseAccount();
}


Uma vez que ambos SavingsAccount e CheckingAccount derivam de BankAccountProtected, é possível atribuir-lhes o bankAccts array. Elas se sobrepõem a ambos os métodos de BankAccountProtected protegida virtual, por isso é o SavingsAccount CheckingAccount e métodos que são chamados quando CloseAccount em BankAccountProtected executa. Lembre-se que a única razão pela qual os métodos de SavingsAccount CheckingAccount e pode chamar os seus métodos de classe base virtual, como no caso do DeleteAccountFromDB, porque é a classe base virtual métodos são marcados com o acesso protegido modificador.

Tipo: Access Modifiers


Até agora, a discussão do acesso modificadores tem apenas aplicado aos membros de tipos. Porém, as regras são diferentes para os tipos de si mesmos. Quando se fala de tipos, Estou me referindo a todos os tipos do C #, incluindo as classes, structs, interfaces , Delegados, e enums. Nested types, such as a class defined within the scope of a class, are considered type members and fall under the same access rules as other type members. Aninhados tipos, tais como uma classe definida dentro do escopo de uma classe, são considerados membros tipo e do âmbito do acesso ao mesmo tipo de regras que os outros membros.

Só pode ter dois tipos de acesso modificadores: público ou interno. O padrão, se você não especificar o acesso modificador, é interno. Olhando para todas as classes usadas nesta lição, você pode ver que eles são internos porque eles não trabalham Não têm um acesso modificador. Você pode especificar explicitamente interna como este:
 internal class InternalInterestCalculator
{
    // members go here
}


Talvez a InternalInterestCalculator, mostrado acima, tem regras especiais negócio que você não quer outro código a ser usado. Agora, ela está em uma biblioteca de sua própria classe e só podem ser acessados por outros código dentro da mesma classe que a DLL (biblioteca).

Nota: Para ser mais específico, significa que apenas código interno na mesma assembléia pode acessar marcados como código interno. No entanto, discutir a definição de uma assembléia está fora do escopo desta lição, por isso estou simplificando a terminologia.

Se você declarada uma classe dentro de uma classe biblioteca que você queria outro código a usar, lhe daria acesso público um modificador. O código a seguir mostra um exemplo de aplicação do acesso público a um modificador tipo:
 public class BankAccountExternal
{
    // members go here
}


Certamente, uma conta bancária é algo que você gostaria de acessar uma classe de fora da biblioteca. Portanto, ela só faz sentido para dar-lhe um acesso público modificador como mostrado no BankAccountExternal classe acima.

Sugestão: Uma comum gottcha do Visual Studio 2005 ocorre quando você cria uma nova classe em uma classe biblioteca. O modelo padrão não inclui um acesso modificador. Então, quando você tenta escrever código que utiliza a nova classe em seu programa (que o remissões classe biblioteca), obtém-se um compilador de erro dizendo que a classe não existe. Bem, você sabe que você só existe porque o escreveu e estão a olhar para a página. Caso você já tenha visto a pista Dei-lhe até agora, você tecla sobre o fato de que o modelo padrão deixada de fora do acesso modificador do tipo. Isto torna o padrão para a classe interna, que não pode ser visto do lado de fora da montagem. A correção é para dar ao público uma classe modificador, como o BankAccountExternal classe acima.

Resumo


Encapsulamento é um objeto-orientado princípio de esconder o estado interno e comportamento de um objeto, tornando o código mais sustentável.Em C #, você pode gerenciar encapsulamento com acesso modificadores. Por exemplo, o acesso público modificador permite o acesso a qualquer código, mas o acesso privado modificador restringe o acesso aos membros de um só tipo. Outras acesso modificadores restringir o acesso algures no intervalo entre público e privado. Embora você possa utilizar todas as possibilidades de acesso modificadores de tipo membros, o acesso apenas dois modificadores que você pode usar são os tipos de público e internos.

Artigo automaticamente traduzido de: http://www.csharp-station.com/Tutorials/lesson19.aspx

Mais sobre: curso_c_sharp c#
Share Tweet
Recomendado
Comentários
Carregar comentários
Destaquesver tudo