Arquivos da categoria: Aprendendo a programar

ADO.NET: Manipulando banco de dados no .NET Framework

Este tópico vai tratar como acessar base de dados relacionais no .NET Framework.

Toda linguagem/plataforma de programação disponibiliza meios de acesso e manipulação de dados em banco de dados relacional, no .NET Framework não é diferente e trouxe consigo uma forma única e padronizada de acesso a dados, chamada ADO.NET, visando não só aplicações locais, mas também a Internet e os dispositivos móveis.

O ADO.NET é uma tecnologia baseada no clássico ADO (Active Data Objects) e faz parte de um conceito chamado UDA (Universal Data Access), o que permite que aplicativos se comuniquem com as mais diversas bases de dados usando a mesma metodologia, os mesmos objetos, a mesma abordagem. Ou seja, com o ADO.NET é possível acessar uma base dados SQL Server, Oracle, Firebird, Informix, PostGress, MySQL, e por aí vai…, sempre do mesmo jeito. Não temos que ficar apredendo uma nova forma acesso para cada tipo de SGBD.

Após definir o SGBD da aplicação é necessário procurar seu um provider .NET. A maioria dos fornecedores de SGBD disponibilizam em seus sites os providers. O provider para o SQL Server vem incluso na plataforma .NET. Se o SGBD escolhido não possui o provider, então é possível usar os providers genéricos ODBC ou OLEDB.

Os esses provider, tanto o específico (pode ser chamado de Nativo) como os genéricos são baseados num conjunto de classes, interfaces, tipos e enumerações, fornecedidos pelo .NET Framework o que permite aos fornecedores de bancos de dados implementarem as interfaces que permitirão acesso aos seus respectivos SGBDs, por isso é possível acessar diferentes SGBDs usando a mesma metodologia.

Este post vai utilizar o SGBD SQLServer nos exemplos com a base de dados Nortwind. Para usar outro SGBD, o provider deste deve ser referenciado ao projeto.

Estabelecendo uma conexão

Só é possível manipular uma base de dados após o estabelecimento da conexão. O ADO.NET oferece uma classe de interface para isso, a System.Data.IDbConnection. E para cada SGDB que possua seu provider específico existe a implementação dessa interface. Para o SQL Server a classe é SqlConnection, para o Oracle a OraConnection, para o MySQL a MySqlConnection, e por aí vai.

Para acontecer a conexão do ADO.NET com o banco de dados, é necessário informar o computador onde está o banco de dados, qual seu usuário e senha, através de uma string de conexão, que para cada SGBD é diferente. O site http://www.connectionstrings.com mantém uma ótima relação de tipos e strings de conexão.

Sabendo de tudo isso, aí vai o primeiro exemplo usando o banco de dados Northwind que acompanha o SQL Server Express.

//Importação do provider do SQLServer
using System.Data.SqlClient;

namespace appTeste
{
    class Program
    {
        static void Main(string[] args)
        {
            //Criação do objeto de conexão apontado para o banco de dados através da string de conexão.
            SqlConnection con = new SqlConnection(@"Data Source=.SQLEXPRESS;Initial Catalog=Northwind;Persist Security Info=True;User ID=usuario; Password=senha");

            //Abertura do banco de dados
            con.Open();

            //Fechamento do banco de dados
            con.Close();
        }
    }
}

Para estabelecer a conexão não há segredo. É importar o provider, instanciar o objeto de conexão informando a string de conexão para a base e dados, abrir e fechar a conexão.

Uma boa prática de programação não demostrada aqui é sempre usar tratamento de erros ao acessar um banco de dados.

Definindo instruções SQL

A executação de instruções SQL é de responsabilidade da classe de interface System.Data.IDbCommand. Da mesma forma que acontece com a classe Connection, existe uma implementação para cada SGDB.

Um objeto do tipo Command deve estar ligado a uma conexão através de sua propriedade Connection e a instrução SQL a ser executada deve ser adicionada na propriedade CommandText no formato de string.

//Importação do provider do SQLServerusing System.Data.SqlClient;
using System.Data.SqlClient;

namespace appTeste
{
    class Program
    {
        static void Main(string[] args)
        {
            //Criação do objeto de conexão apontado para o banco de dados através da string de conexão.
            SqlConnection con = new SqlConnection(@"Data Source=.SQLEXPRESS;Initial Catalog=northwind;Persist Security Info=True;User ID=usuario; Password=senha");

            //Abertura do banco de dados
            con.Open();

            //Criando o objeto command para execução de instruções SQL
            SqlCommand cmd = new SqlCommand();

            //Ligando o Command a conexão.
            cmd.Connection = con;

            //Informando a instrução SQL.
            cmd.CommandText = "Insert into Region (RegionID, RegionDescription) Values (1000, 'Região...')";

            //Fechamento do banco de dados
            con.Close();
        }
    }
}

Um objeto do tipo Command possui a propriedade CommandType que define o tipo da execução. O valor padrão é Text, e indica que a string informada na propriedade CommandText é uma instrução Insert, Update, Delete ou Select.  Para executar Stored Procedures seu valor deve ser alterado para StoredProcedure.

cmd.CommandType = System.Data.CommandType.StoredProcedure;

Executando instruções SQL

Com a instrução SQL definida no objeto do tipo Command é possível executá-la. O objeto fornece basicamente três métodos de execução, o ExecuteNonQuery, ExecuteScalar e ExecuteReader.

1. ExecuteNonQuery: Utilizado quando se quer executar uma instrução que não retorna como resultado um conjunto de dados: Insert, Update, Delete e chamada a Stored Procedure. Seu retorno é um valor inteiro indicando o número de linhas afetadas na base de dados.

cmd.CommandText = "Insert into Region (RegionID, RegionDescription) Values (1000, 'Região...')";

if (cmd.ExecuteNonQuery() > 0)
    Console.WriteLine("Inserido");
else Console.WriteLine("Não inserido");
cmd.CommandText = "Delete From Region Where RegionID = 1000";

if (cmd.ExecuteNonQuery() > 0)
    Console.WriteLine("Excluído");
else Console.WriteLine("Não excluído");

2. ExecuteScalar: Retorna um único valor (uma coluna e uma linha). Tem seu desempenho otimizado para ser usado em funções SQL de agregação como count(*), sum(campo), avg(campo), max(campo), etc. Seu retorno é um objeto do tipo object, o que significa que pode representar qualquer tipo de dados.

cmd.CommandText = "Select Count(*) From Region";

object conta = cmd.ExecuteScalar();

if (conta != null)
    Console.WriteLine("Quantidade de registros: " + conta);
cmd.CommandText = "Select Max(RegionID) From Region";

object maxRegionId = cmd.ExecuteScalar();

int proximoRegionId;

if (maxRegionId == null)
    proximoRegionId = 1;
else proximoRegionId = Convert.ToInt32(maxRegionId) + 1;

Console.WriteLine("Próximo registro: " + proximoRegionId);

3. ExecuteReader: Utilizado para executar consultas (querys) que retornam um conjunto de dados. Este método tem como returno um objeto do tipo DataReader. Um objeto do tipo DataReader representa um cursor aberto somente para a frente e somente de leitura no banco de dados com os dados retornado de uma consulta. Após a leitura completa dos dados é necessário fechar o DataReader. Só é possível ter um DataReader aberto por conexão.

Um objeto do tipo DataReader somente dá acesso a uma linha do resultado por vez, e inicialmente não aponta para primeira linha. Através do método Read é possível acessar cada linha indivualmente, além disso retorna um valor booleano indicando se foi possível mover para a próxima linha. Para acessar a primeira linha do resultado é necessário usar o método Read movendo o cursor para ela.

cmd.CommandText = "Select RegionID, RegionDescription From Region";

//Executando a consulta e recuperando o DataReader com o resultado
SqlDataReader dr = cmd.ExecuteReader();

//Para acessar a primeira linha é necessário mover o cursor para ela.
if (dr.Read())
    Console.WriteLine(dr["RegionDescription"]);

//Liberando o cursor.
dr.Close();

Basta usar uma estrutura de repetição para percorrer todas as linhas do resultado.

while (dr.Read())
    Console.WriteLine(dr["RegionDescription"]);

//Liberando o cursor.
dr.Close();

Importante destacar que não é possível acessar uma linha que já foi lida pelo DataReader, pois ele é um cursor que somente anda para frente.

Usando parâmetros nas instruções SQL

Uma boa prática é utilizar parâmetros e evitar a concatenação de strings para passar valores para as instruções SQL. Para indicar um parâmetro dentro da instrução, o SQL Server utiliza o símbolo “@”. Esta sintaxe pode variar de acordo com o banco de dados utilizado (o Oracle utiliza “:”).

Para atribuir valores aos parâmetros é necessário criar objetos de classes que implementam a interface System.Data.IDbDataParameter e adicioná-los ao objeto de comando (Command) na propriedade Parameters. No SQL Server a implementação é a classe SqlParameter.

cmd.CommandText = "Insert into Region (RegionID, RegionDescription) Values (@RegionID, @RegionDescription)";

//Criando os parâmetros e atribuindo valores
SqlParameter regionID = cmd.CreateParameter();
regionID.ParameterName = "@RegionID";
regionID.Value = "1000";
//adicionando o parâmetro ao Command
cmd.Parameters.Add(regionID);

SqlParameter regionDescription = cmd.CreateParameter();
regionDescription.ParameterName = "@RegionDescription";
regionDescription.Value = "Região...";
//adicionando o parâmetro ao Command
cmd.Parameters.Add(regionDescription);

if (cmd.ExecuteNonQuery() > 0)
    Console.WriteLine("Inserido");
else Console.WriteLine("Não inserido");

Também é possível utilizar métodos da propriedade Parameters do objeto Command para criar rapidamento os parâmetros e passar os valores.

cmd.CommandText = "Insert into Region (RegionID, RegionDescription) Values (@RegionID, @RegionDescription)";

//Criando os parâmetros e atribuindo valores ao mesmo tempo
cmd.Parameters.AddWithValue("RegionID", 1000);
cmd.Parameters.AddWithValue("RegionDescription", "Região....");

if (cmd.ExecuteNonQuery() > 0)
    Console.WriteLine("Inserido");
else Console.WriteLine("Não inserido");

//Limpando a lista de parâmetros para aproveitar o mesmo Command
cmd.Parameters.Clear();

cmd.CommandText = "Delete From Region Where RegionID = @RegionID";
cmd.Parameters.AddWithValue("RegionID", 1000);

if (cmd.ExecuteNonQuery() > 0)
    Console.WriteLine("Excluído");
else Console.WriteLine("Não excluído");

Em algumas situações temos fornecer mais detalhes sobre os parâmetros além de seu nome e valor, por exemplo definir o tamanho da informação, o tipo de dados, ou mesmo informar que determinado parâmetro  é de saída (que retorna valores).

SqlParameter regionID = cmd.CreateParameter();
regionID.ParameterName = "@RegionID";
regionID.Direction = System.Data.ParameterDirection.Output;
regionID.DbType = System.Data.DbType.String;
regionID.Size = 20;

Transações

Muitas vezes é necessário trabalhar com operações de insert, update ou delete que envolvem diversas tabelas, no estilo execute tudo ou nada. Um exemplo clássico é uma operação a venda de produtos, onde não pode haver uma venda de um produto sem um atualização em seu respectivo estoque.

No .NET transações são gerenciadas por objetos de classes derivados da interface System.Data.IDbTransaction, como a SqlTransacation para SQL Server.

//Abertura do banco de dados
con.Open();

//Criando o objeto de transação e iniciando
SqlTransaction transacao = con.BeginTransaction();

//Criando o objeto command e associando à transação
SqlCommand cmd = new SqlCommand();
cmd.Connection = con;

try
{
    cmd.Transaction = transacao;

    //Executando a primeira atualização da base dados
    cmd.CommandText = "Delete from Products Where CategoryID = 1";
    cmd.ExecuteNonQuery();

    //Executando a segunda atualização da base dados
    cmd.CommandText = "Delete Categories Where CategoryID = 1";
    cmd.ExecuteNonQuery();

    //Confirmando as atualizações na base de dados, pois NÃO ocorreram erros.
    transacao.Commit();
}
catch
{
    //Desfazendo as atualizações na base de dados, pois ocorreram erros.
    transacao.Rollback();
}

con.Close();

É isso pessoal. Espero que ajude. 😉

Validar a quantidade de caracteres num TextBox MultiLine (TextArea)

Sabemos que para transformar o ServerControl TextBox em TextArea temos que mudar sua propriedade TextMode para o valor MultiLine. Também sabemos que via HTML não é possível limitar o tamanho de um TextArea por meio do MaxLength como é feito num Input Text. Isso pode ser contornado com o uso de Javascript.

Usando o controle ASP.NET RegularExpressionValidator e a expressão regular ^.[sS]{0,500}$, é possível validar a quantidade de caracteres inseridas num TextBox MultiLine (TextArea). Na expressão acima, o valor 500 é a quantidade máxima de caracteres que desejamos no TextBox MultiLine (TextArea).

<asp:TextBox ID="TextBox1" runat="server" Height="93px" TextMode="MultiLine" Width="381px"></asp:TextBox>
<br />
<asp:RegularExpressionValidator ID="RegularExpressionValidator1" runat="server" ControlToValidate="TextBox1"
  ErrorMessage="Ultrapassou 500 caracteres." ValidationExpression="^.[sS]{0,500}$">
</asp:RegularExpressionValidator>

Bom proveito.

Definindo classes em C# – Parte 5

Passagem de parâmetros: Os modificadores in/out/ref

Ao criamos parâmetros em métodos na linguagem C#, por padrão estes parâmetros são passados por valor, ou seja, se os valores dos parâmetros forem alterados durante a execução do método, a mudança não será refletida na variável passada por parâmetro. Este comportamento é atribuído ao modificador de parâmetro in, e é implícito, não precisa ser informado.

public void Metodo1(int p1)
{
     p1 = 1000;
}

No exemplo acima, mesmo que o parâmetro p1 fosse alterado dentro do método seu valor externamente não seria modificado. Este comportamento pode ser alterado utilizado os moficadores ref e out.

O modificador ref

O parâmetro ref permite a passagem de valores por referência. Neste caso, os valores modificados dentro do método refletem para o bloco de código que fez a chamada. Na utilização, o operador ref é necessário tanto na declaração do parâmetro como também na chamada do método. E ainda o uso do ref requer que a variável a ser passada como parâmetro seja inicializada antes de passar sua referência. No exemplo abaixo, a variável valor é inicializada com o valor 1000, e depois é enviado por referência ao método.

double valor = 1000.00;
Metodo2(ref valor);

...

public void Metodo2(ref double p1)
{
     p1 = 0;
}

O modificador out

A diferença entre o modificador out e o ref, é que o out permite a passagem de uma variável não inicializada por parâmetro, o que não é permitido em parâmetros do tipo ref.

double valor;
Metodo3(out valor);

...

public void Metodo3(out double p1)
{
     p1 = 1000;
     ...
     ...
}

Outra difrença no uso do modificador out, é que o parâmetro obrigatoriamente deve ter um valor atribuído dentro do método, antes de deixá-lo. No exemplo acima, o parâmetro p1 recebe o valor 1000.

Um método naturalmente só pode retornar um valor através da palavra reservada return. Um prática comum é usar parâmetros out para retornar vários.

Definindo classes em C# – Parte 4

Herança

Herança é um tipo de relacionamento/associação entre classes. É usada quando é necessário que uma determinada classe tenha todas as características de outra classe com algumas modificações em seu comportamento, ou mesmo algumas funcionalidades adicionais.

As palavras generelização e especialização fazem parte do conceito de Herança. Uma classe “mais genérica” (generelização) pode gerar uma nova classe que herda suas características, mas permitindo modificações e novas implementações, ou seja, a nova classe é uma especialização da classe genérica.

Um exemplo tradicional usado para explicar o conceito de herança é a definição das classes Pessoa, PessoaFisica e PessoaJuridica. A classe Pessoa é genérica, e contém atributos, métodos e propriedades que podem representar qualquer pessoa. Já as classes PessoaFisica e PessoaJuridica respectivamente representam uma características para uma pessoa física e pessoa jurídica, e são classes especializadas, pois especializam a classe Pessoa.

Em C# uma relação de Herança é implementada com o uso do símbolo “:” (dois pontos) na definição da classe.

Classe genérica (Pessoa).

public class Pessoa
{
    int _id;
    DateTime _dataCadastro;

    public int Id
    {
        get { return this._id; }
        set { this._id = value; }
    }

    public DateTime DataCadastro
    {
        get { return _dataCadastro; }
        set { _dataCadastro = value; }
    }

    public int GerarId()
    {
        throw new NotImplementedException();
    }
}

Classes especializadas PessoaFisica e PessoaJuridica.

public class PessoaFisica: Pessoa
{
    string _nome;
    DateTime _dataNascimento;
    string _cpf;

    public string Nome
    {
        get { return _nome; }
        set { _nome = value; }
    }

    public DateTime DataNascimento
    {
        get { return _dataNascimento; }
        set { _dataNascimento = value; }
    }

    public PessoaFisica(int id, DateTime dataCadastro, string nome, string cpf)
    {
        base.Id = id;
        base.DataCadastro = dataCadastro;
        this._cpf = cpf;
        this._nome = nome;
    }

    public PessoaFisica EncontrarPorCpf(string cpf)
    {
        throw new NotImplementedException();
    }
}

public class PessoaJuridica : Pessoa
{
    string _cnpj;
    string _razaoSocial;

    public string Cnpj
    {
        get { return _cnpj; }
        set { _cnpj = value; }
    }

    public string RazaoSocial
    {
        get { return _razaoSocial; }
        set { _razaoSocial = value; }
    }

    public PessoaJuridica(int id, DateTime dataCadastro, string cnpj, string razaoSocial)
    {
        base.Id = id;
        base.DataCadastro = dataCadastro;
        this._cnpj = cnpj;
        this._razaoSocial = razaoSocial;
    }

    public PessoaJuridica EncontrarPorCnpj(string cnpj)
    {
        throw new NotImplementedException();
    }
}

Graficamente a Herança no Diagrama de Classe tem o seguinte aspecto.

Como é possível perceber no exemplo acima, as classes especializadas tem acesso aos membros implementados na classe genérica atráves da palavra reservada base.

Métodos Virtuais

A classe genérica pode oferecer métodos que podem ser reescritos nas classes especializadas. Isso é possível quando um método é decorado com a palavra reservada virtual. Para reescrevê-lo na classe especializada, o método deve ser decorado com a palavra reservada override.

public class Pessoa
{
    ...

    public virtual Pessoa EncontarPorId(int id)
    {
        throw new NotImplementedException();
    }
}

public class PessoaJuridica : Pessoa
{
    ...

    public override Pessoa EncontarPorId(int id)
    {
        //Nova implementação
    }
}

public class PessoaFisica : Pessoa
{
    ...

    public override Pessoa EncontarPorId(int id)
    {
        //Nova implementação
    }
}

Por enquanto é só isso. Até o próximo.

Definindo classes em C# – Parte 3

Sobrecarga de Métodos (overloading)

A linguagem C# permite que métodos diferentes possuam o mesmo nome. Essa implementação é possível pois a assinatura dos métodos são diferentes. Uma assinatura é formada pelo nome do método e sua lista de parâmetros.

Geralmente o uso da sobrecarga está associada quando uma método precisa de uma série de métodos que adotem parâmetros diferentes, mas que fazem conceitualmente a mesma coisa, como por exemplo quando necessitamos ter parâmetros opcionais, diferentes tipos de entrada ou diferentes tipos de saídas (através dos parâmetros).

public void FaçoAlgumaCoisa()
{
}

public void FaçoAlgumaCoisa(int p1)
{
}

public void FaçoAlgumaCoisa(int p1, int p2)
{
}

public void FaçoAlgumaCoisa(string p1, int p2)
{
}

public void FaçoAlgumaCoisa(int p1, int p2, out int p3)
{
}

A invocação dos metódos acontece de forma tradicional. O compilador da linguagem chamará o método correto conforme a lista dos parâmetos.

FaçoAlgumaCoisa();
FaçoAlgumaCoisa(1);
FaçoAlgumaCoisa(1, 2);
FaçoAlgumaCoisa("1", 2);

int x;
FaçoAlgumaCoisa(1,2, out x);

Quando usamos o VisualStudio o autocomplete dá um força mostrando as sobrecargas do método.

Até mais.

Definindo classes em C# – Parte 2

Métodos Estáticos

No post anterior vimos que uma classe pode ser instanciada, e que cada instância é chamada de objeto. Cada objeto é independente, ou seja, instâncias da mesma classe “não se conhecem”, não compartilham dados.

Pessoa pessoa1 = new Pessoa();
Pessoa pessoa2 = new Pessoa(1,"Filogonio Silva",dataNasc);
Pessoa pessoa3 = new Pessoa(2,"Fippildo Silva",dataNasc);

No código acima, as instâncias (ou objetos) da classe Pessoa, pessoa1, pessoa2 e pessoa3 contêm seus próprios dados. Os membros criados na classe somente podem ser vistos por seus respectivos objetos, pois foram definidos como membros de objetos. Há caso que esse não é o comportamento desejado. É possível definir membros da classe, que são chamados de membros estáticos, não sendo necessário instanciar a classe para usá-los.

A declaração de um membro estático se dá através da palavra reservada static. Um membro estático está disponível desde o momento que o programa é executado.

O código abaixo exemplifica a definição de um atributo estático e sua respectiva propriedade (somente get) para retorna seu valor.

//atributo estático
static int _tamanhoNome = 100;

//propriedade estática
public static int TamanhoNome
{
    get { return _tamanhoNome; }
}

Como dito anteriormente, um membro estático existe deste a execução do programa, não sendo necessária a instanciação da classe, basta acessar a classe e invocar o membro estático.

Pessoa pessoa1 = new Pessoa();
Pessoa pessoa2 = new Pessoa(1, "Filogonio Silva", dataNasc);
Pessoa pessoa3 = new Pessoa(2, "Fippildo Silva", dataNasc);

//Uso de propriedade estática.
Response.Write(Pessoa.TamanhoNome);

Para finalizar, é importante destacar que um método estático não pode acessar outros membros da classe que não sejam estáticos.

Até o próximo…

Definindo classes em C# – Parte 1

Olá pessoal.

A ideia deste post não é mostrar o conceito de classe (ou mesmo da Orientação a Objetos), e sim como criar classes na linguagem C#.

Numa aplicação desenvolvida com uma linguagem orientada a objetos o uso de classe é bem comum. Mesmo aplicações pequenas em C# necessitam da elaboração de uma ou mais classes, cada uma com suas propriedades e métodos usados para executar as tarefas relativas ao objeto.

Mas o que é uma classe? Uma classe pode ser definida como um gabarito de um objeto. Acho que agora piorou, certo?

Primeiro vamos entender o que é um objeto. Um objeto na programação OO é qualquer coisa que seja um único item que se queira identificar num programa, como por exemplo uma pessoa, um carro, um computador, uma caneta, um usuário, etc. Mas o que seria a classe? A classe define como esse objeto deve ser, por isso é um gabarito de um objeto.

A classe gera o objeto de acordo com sua estrutura, e esse processo de criação do objeto é chamado de instanciação da classe.

Em C#, podemos ter dentro de uma classe os seguintes membros: atributos, construtores, destrutores, domínios, métodos, propriedades, indexadores, delegates, eventos e classe aninhadas. As classes são declaradas usando a palavra reservada class e precedida de um modificador de acesso, conforme mostrado no exemplo a seguir

public class Pessoa
{
}

Os modificadores de acesso dizem ao compilador da linguagem como classe será acessada externamente. Os moficadores são para classe são:

public: Permite que a classe seja acessada por qualquer outra classe.
selead: Não permite que a classe seja herdada.
partial: Permite que a classe tenha seu escopo dividido em vários arquivos.
static: Especifica que a classe somente tem membros estáticos. Não pode ser instanciada.
abstract: Define moldes para classes filhas. Não pode ser instanciada.

Atributos, Métodos, Propriedades e Construtores

Atributos

Atributo são declarados dentro da classe e são os elementos que definem sua estrutura. São como variáveis da classe.

public class Pessoa
{
    int _id;
    string _nome;
    DateTime _dataNascimento;
}

Métodos

Os métodos são as ações que a classe ou uma instância da classe realização. A declaração de um método contempla um modificador de acesso, um tipo de retorno, o nome do método e opcionalmente parâmetros.

public class Pessoa
{
    int _id;
    string _nome;
    DateTime _dataNascimento;

    public int CalcularIdade()
    {
        int idade = DateTime.Now.Year - this._dataNascimento.Year;
        return (idade);
    }

    public int CalcularIdade(DateTime dataReferencia)
    {
        int idade = dataReferencia.Year - this._dataNascimento.Year;
        return (idade);
    }
}

É possível ter métodos com o mesmos nomes, sendo suas assinaturas diferentes, isso é chamado de sobrecarga de métodos. E ainda é possível criar métodos que não tenham um retorno específico usando a palavra reservada void.

protected void FazAlgumaCoisa()
{
    //Faz alguma coisa e não retorna...
}

Um método é classificado em “Contexto de Ação”, quando é centrado nos processos e atividades realizadas. Ex.: impressão de um cabeçalho padrão, mudança de configuração de tela, mudança de um status, etc. Normalmente não possuem retorno. É classificado como “Contexto de Resultado”, quando o objetivo é calcular ou obter algum valor em especial. Ex.: validação, resultado de um cálculo, etc. Normalmente retorna um valor.

Propriedades

Algumas linguagens de programação implementam o conceito Propriedades em suas características de Orientação a Objetos. Alguns puristas não concordam com uso, pois alegam que fere alguns conceitos tradicionais da OO.

A linguagem C# promove o uso de Propriedades, que são métodos que protegem (encapsulam) o acesso a membros da classe, ou seja, separa os elementos visíveis de um objeto dos invisíveis. As propriedades podem ser substituidas pelo clássico uso dos métodos set e get.

public class Pessoa
{
    int _id;

    public int Id
    {
        get { return _id; }
        set { _id = value; }
    }

    string _nome;

    public string Nome
    {
        get { return _nome; }
        set { _nome = value; }
    }

    DateTime _dataNascimento;

    public DateTime DataNascimento
    {
        get { return _dataNascimento; }
        set { _dataNascimento = value; }
    }
}

Na classe acima todos atributos foram encapsulados por propriedades, por exemplo o atributo int _id foi encapsulado pela propriedade public int Id. A propriedade Id poderia ter sido substituída sem problemas por um método set e get.

int _id;

public int GetId
{
    return _id;
}

public int SetId
{
    _id = value;
}

Modificações de acesso para atributos, métodos e propriedades

Atributos, métodos e propriedades necessitam de moficadores de acesso. Os principais para estes recursos são:

Public: Permite que os membros das classes sejam acessados por qualquer outro escopo
Protected: Permite que membros sejam usados apenas pela classe que o contém e permite que estes sejam “herdados” para classes derivadas da original.
Private: O membro é de uso exclusivo da classe onde é declarado.
Internal: Permite acesso somente por classes do mesmo assemblie.
Static: Permite acesso, sem necessidade do objeto ser instanciado.
Abstract: São métodos de classes Abstract que não possuem implementação (sem codificação).
Virtual: Permite que os métodos sejam sobrescritos por classes filhas.
Readonly:Limita acesso a somente leitura aos atributos da classe

Construtores

As classes podem apresentar métodos de inicialização chamados de construtores. São métodos responsáveis por inicializar os objetos das classes (instâncias das classes). E são identificados por um método com o mesmo nome da classe e sem retorno.

public class Pessoa
{
    public Pessoa()
    {

    }

    public Pessoa(int id, string nome, DateTime dataNascimento)
    {
        _id = id;
        _nome = nome;
        _dataNascimento = dataNascimento;

    }
    ...

Acima foram criados dois construtores, o primeiro não faz nada (construtor padrão) e o segundo recebendo valores para inicializar os atributos da classe.

Instanciando classes

A instanciação da classe ocorre através da palavra reservada new. Se uma classe é estática (static) ela tem um comportamente diferente, não sendo necessário fazer sua instanciação para uso.

Pessoa pessoa1 = new Pessoa();
Pessoa pessoa2 = new Pessoa(1,"Filogonio Silva",dataNasc);
Pessoa pessoa3 = new Pessoa(2,"Fippildo Silva",dataNasc);

Existe outros conceitos (mais avançados) envolvendo classes. Aqui é só um “aquece”.

Até mais.

Impulsione sua carreira: Centro de Treinamento

O Centro de Treinamento é um programa de capacitação técnica online e gratuita, com uma série de trilhas que irão te ajudar a construir um portfolio de habilidades técnicas. O Centro de Treinamento agrega a sólida fundação de conteúdo técnico distribuído através de canais já conhecidos do MSDN e TechNet como webcasts, videocasts, artigos e blog oficiais da Microsoft. Todo conteúdo é organizado de maneira guiada e fácil de acessar para que você possa aprender as habilidades mais importantes.

Para testar seus conhecimentos, você pode opcionalmente realizar uma prova relacionada ao conteúdo ou módulo estudado*.

Saiba mais aqui.

Programação é igual a educação, deve começar no berço

Para quem está iniciando na Aventura de programar computadores, aqui vão três dicas, na verdade três links :-)

C# para crianças: http://msdn.microsoft.com/pt-br/beginner/bb308756.aspx ou http://msdn.microsoft.com/en-us/beginner/bb308756.aspx

Cantinho das crianças: http://msdn.microsoft.com/pt-br/beginner/bb308754.aspx

E boa aventura…

 

Concatenação de string (C#)

A concateção de strings é algo muito comum no dia-a-dia. Normalmente fazemos a conteção da seguinte forma:

string str = “linha 1″ +
” linha 2  ” +
” linha 3 “;

Isso é bem comum quando temos instruções SQL embutidas na linguagem.

E que tal fazer a concateção assim:

string str = @”linha 1
linha 2
linha 3“;

Observer o caracter @ antecedendo a string. E ele que faz toda a diferença. Muito mais prático, não?