Neste tutorial veremos como solucionar o erro “”SqlConnection” não pode ser encontrado no namespace “System.Data.SqlClient“” em uma aplicação C# escrita no Microsoft Visual Studio.

Problema

Durante uma aula de programação com C#, ao tentar criar uma aplicação com GUI usando o Microsoft Visual Studio 19 e o .NET 5.0, os alunos se depararam com o erro a seguir ao codificar a aplicação:

Os objetos SqlConnection, SqlCommand e SqlDataReader não eram reconhecidos mesmo após a inclusão do namespace System.Data.SqlClient na seção de diretivas “using“ do programa.

Ao tentar executar o código, as seguintes mensagens de erro eram mostradas na saída:

Por que esse erro ocorre

O que causa desse erro é o fato do namespace System.Data.SqlClient não ter sido referenciado pelo projeto por padrão, conforme deveria ser feito pelo .NET Framework. Assim, para corrigir esse problema, será necessário adicionar o pacote manualmente ao projeto.

Como resolver o problema

Solução: instalar o pacote System.Data.SqlClient no NuGet para que o projeto possa utilizá-lo. Siga os passos abaixo para realizar essa tarefa.

1. Clique com o botão direito do mouse no nome da solução no painel de soluções do Visual Studio.
2. No menu de contexto, selecione Gerenciar Pacotes NuGet para a Solução…
3. Na janela Gerenciador de Pacotes NuGet, clique na guia Procurar.
4. Na caixa de pesquisa digite System.Data.SqlClient e pressione Enter.
5. Procure o pacote System.Data.SqlClient da Microsoft e o selecione.

   

6. Um pequeno painel será aberto no lado direito da janela. Selecione a versão do pacote a instalar (geralmente a mais recente funcionará) e pressione o botão de instalação. Aguarde a conclusão da instalação. O NuGet irá instalar o pacote selecionado e todas as suas dependências.
7. Após o término da instalação do System.Data.SqlClient retorne ao seu projeto e tente executá-lo novamente. Se tudo correu bem, você não verá o erro ocorrendo outra vez.

Problema solucionado!

O post Erro O nome do tipo “SqlConnection” não pode ser encontrado no namespace “System.Data.SqlClient” (Resolvido) – Visual Studio apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma lista em C# é um objeto que armazena dados de um determinado tipo em uma ordem específica. Representa uma lista fortemente tipada de objetos que podem ser acessados por meio de um número de índice. O tipo de dado que a lista armazena é definido usando a sintaxe de genéricos. Por exemplo, vamos definir uma lista genérica de nome valores que irá armazenar números inteiros:

List<int> valores = new List<int>();

As listas em C# fazem parte do namespace System.Collection.Generic.

Diferença entre lista e array em C#

A diferença entre listas e arrays é a de que as listas possuem tamanho dinâmico (ajustável), ao passo que os arrays possuem tamanho fixo. Por conta disso, as listas são indicadas para quando não sabemos de antemão a quantidade de dados que serão armazenados. Uma lista armazena itens de um tipo especificado e cresce automaticamente quando novos itens (do mesmo tipo) são adicionados.

As listas são ideais para o armazenamento e recuperação de grandes números de elementos, como retornos de consultas a bancos de dados, por exemplo. Sua capacidade máxima em um sistema de 64 bits é de 2 bilhões de elementos. A capacidade de uma lista pode ser acessada ou ajustada por meio da propriedade Capacity.

Vamos estudar algumas operações que podem ser realizadas em listas em C#, usando Windows Forms e o Visual Studio para codificar nossos testes.

Propriedades e métodos da classe List<T>

A seguir temos algumas das principais propriedades e métodos da classe List<T> em C#:

Propriedades

• Items – Obtém ou grava o elemento na posição de índice especificada
• Count – Retorna o número total de elementos que existem na lista.

Métodos

• Add – Adiciona um elemento ao final da lista
• AddRange – Adiciona elementos de uma coleção especificada ao final da lista
• Clear – Remove todos os elementos de uma lista
• Contains – Verifica se um elemento especificado existe ou não em uma lista
• Insert – Insere um elemento em uma posição (índice) especificada na lista
• Remove – Remove a primeira ocorrência de um elemento especificado
• RemoveAt – Remove o elemento em uma posição especificada na lista
• Sort – Ordena os elementos da lista 

Inserir items em uma lista

Após inicializar uma lista, podemos inserir valores invocando o método Add():

List<int> valores = new List<int>();
valores.Add(16);
valores.Add(18);
valores.Add(23);
valores.Add(12);

Alternativamente, podemos inserir um array de itens de uma só vez usando o método AddRange():

List<int> valores = new List<int>();
int[] numeros = new int[] {16, 18, 23, 12};
valores.AddRange(numeros);

Contar os elementos da lista

Com o método Count podemos determinar quantos elementos uma lista possui:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12 };
valores.AddRange(numeros);
MessageBox.Show("A lista tem " + valores.Count() + " itens.");

Acessar um elemento na lista

Podemos acessar um elemento em uma lista genérica usando seu número de índice, que inicia em 0 (zero). Por exemplo, para acessar o primeiro elemento da lista do exemplo anterior podemos adicionar a seguinte linha de código:

MessageBox.Show("Primeiro item da lista: " + valores[0]);

Perceba a notação de colchetes usada para especificar o elemento 0 da lista: [0].

Remover itens de uma lista em C#

Usamos os métodos Remove e RemoveAt para remover itens de uma lista. O método Remove remove a primeira ocorrência do item especificado, ao passo que o método RemoveAt remove o item em uma posição de índice desejada.
Vamos aos exemplos.

1 – Remover a primeira ocorrência de um item. Vamos remover a primeira ocorrência do valor 18 em uma lista na qual esse valor aparece armazenado em duas posições distintas:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12, 22, 11, 18 };
valores.AddRange(numeros);
string strValores = String.Empty;

foreach (int item in valores)
{
  strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

valores.Remove(18); // Remove a primeira ocorrência do valor 18

strValores = String.Empty;
foreach (int item in valores)
{
  strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

2 – Agora vamos remover o quarto item da lista (índice 3).

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12, 22, 11, 18 };
valores.AddRange(numeros);
string strValores = String.Empty;

foreach (int item in valores)
{
strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

valores.RemoveAt(3); // Remove o item no índice 3 (quarto item)
strValores = String.Empty;
foreach (int item in valores)
{
strValores += "\n" + item.ToString();
}
MessageBox.Show("Lista de valores: " + strValores);

Note que o valor 12, que é o quarto valor em nossa lista inicial, foi eliminado.

Inserir itens em uma lista em posição específica

Podemos inserir um elemento em uma lista em uma posição especificada usando o método Insert. Sua sintaxe é como segue:

Lista.Insert(Índice, Valor);

Esse método aceita dois argumentos:

• Índice – Posição na qual o item será inserido
• Valor – Valor do item a ser inserido na lista

Vejamos um exemplo. Vamos inserir o valor 13 na posição #2 (índice 1) de uma lista que já continha valores armazenados:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12 };
valores.AddRange(numeros);

MessageBox.Show("Segundo item da lista: " + valores[1]);

valores.Insert(1, 13); // Inserimos o valor 13 na segunda posição da lista
MessageBox.Show("Segundo item da lista: " + valores[1]);

Iterar pelos itens de uma lista

Podemos iterar pelos itens em uma lista genérica usando um laço foreach. Veja no exemplo a seguir, codificado em um botão usando Windows Forms no Visual Studio:

List<int> valores = new List<int>();

valores.Add(16);
valores.Add(18);
valores.Add(23);
valores.Add(12);

string strValores = String.Empty;

foreach(int item in valores)
{
  strValores += "\n" + item.ToString();
}

MessageBox.Show("Lista de valores: " + strValores);

Procurar um item em uma lista genérica

Com o método Contains podemos descobrir se um valor especificado existe em uma lista, o seja, se esse item está armazenado na lista. Ele retorna o booleano true se o valor for encontrado, e false se não for encontrado na lista. Por exemplo, queremos saber se o valor 16 está presente em uma lista:

List<int> valores = new List<int>();
int[] numeros = new int[] { 16, 18, 23, 12, 22, 11, 18 };
valores.AddRange(numeros);
string strValores = String.Empty;

int valorProcurado = 16;
bool valorExiste;

valorExiste = valores.Contains(valorProcurado);

if (valorExiste)
{
  MessageBox.Show("O item foi encontrado na lista");
}
else
{
  MessageBox.Show("Item inexistente na lista");
}

O método Contains da lista valores retorna true neste exemplo, pois o valor 16 está presente na lista genérica.

Preencher um ListBox com itens de uma lista

Suponha um controle ListBox de nome lstList, o qual queremos preencher com os elementos armazenados em uma lista genérica.

List<string> lugares = new List<string>();

lugares.Add("Fortaleza");
lugares.Add("Buenos Aires");
lugares.Add("Cairo");
lugares.Add("Sydney");
lugares.Add("Lima");
lugares.Add("Toronto");

foreach (string item in lugares)
{
  lstLista.Items.Add(item);
}

A caixa de listagem também pode ser preenchida usando-se o método ToArray da lista, em vez de usar um laço foreach, para passar seus elementos de uma vez à ListBox:

lstLista.Items.AddRange(lugares.ToArray());

Classificar Listas

Podemos classificar (ordenar) uma lista em C# empregando o método Sort(). Por exemplo, para ordenar a lista de valores usada nos exemplos anteriores, basta executarmos:

valores.Sort();

E os itens dentro desta lista estarão ordenados, em ordem numérica crescente.

É isso aí! Nos próximos tutoriais vamos abordar outras estruturas de armazenamento em C#, tais como Filas e Pilhas. Até!

O post Listas em C# – A classe genérica List<T> apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Neste artigo vamos mostrar como criar e efetuar operações aritméticas básicas com Números Complexos em C#.

O Namespace System.Numerics

O namespace System.Numerics contém diversos tipos numéricos usados para complementar os tipos primitivos, como Int32 e Double, definidos no framework .NET.

Dentre as estruturas implementadas pelo namespace System.Numerics podemos citar: Plane (plano no espaço tridimensional), Vector2 (vetor com dois valores), Matrix4x4 (Matriz 4×4) e Complex (números complexos – objeto deste artigo), entre outras.

A Estrutura Complex

A estrutura Complex, do namespace System.Numerics, permite representar números complexos e realizar diversas operações com esses números. Vamos começar mostrando como criar uma instância de um número complexo em C#.

Como criar uma instância de um número complexo

Para criar uma instância de um número complexo em C# devemos passar dois valores do tipo Double para o construtor. O primeiro valor representa a parte real do número complexo, e o segundo valor representa a parte imaginária.

Exemplo: Vamos criar o número complexo 2+5i em C#:

Complex c1 = new Complex(2,5);
// Mostrar o valor do número complexo (forma padrão C#):
Console.WriteLine(c1);

Propriedades de Complex

Podemos exibir as partes real e imaginária de um número complexo com as respectivas propriedades real e imaginary de um objeto Complex:

Console.WriteLine("Parte real: " + c1.Real) ;
Console.WriteLine("Parte imaginária: " + c1.Imaginary);

Obs.: As propriedades Real e Imaginary são somente-leitura, de modo que não é possível modificar os valores de um objeto Complex já criado. Os métodos que executam operações em objetos Complex retornam um novo número complexo, caso o tipo de retorno seja Complex também.

É possível exibir o número complexo no formato matemático a + bi aplicando formatação com o método Format da classe String, como segue:

// Exibir o número no formato a+bi:
Console.WriteLine(String.Format("{0} + {1}i", c1.Real, c1.Imaginary));

Operações com números complexos em C#

A estrutura Complex possui operadores que permitem realizar diversas operações aritméticas com números complexos, tais como adição, subtração, multiplicação, divisão e negação. Além disso, inclui métodos para executar outras operações numéricas, como exponenciação, raiz quadrada e valor absoluto de um número complexo, além de operações trigonométricas.

Exemplo: Vamos criar e somar dois números complexos. Para isso usaremos a operação Add(num1,num2), onde:

• num1 = primeiro número complexo a adicionar
• num2 = segundo número complexo a adicionar

A adição de números complexos é realizada adicionando-se cada parte separadamente, de acordo com a fórmula:

(a+bi) + (c+di) = (a+c) + (b+d)i

Esta operação em C# retorna um valor do tipo Complex. Vejamos um exemplo:

Complex c1 = new Complex(2,5);
Complex c2 = new Complex(3, 11);
Complex c3 = Complex.Add(c1, c2);
Console.WriteLine("Soma: " + String.Format("{0} + {1}i", c3.Real, c3.Imaginary));

Exemplo 02: Multiplicação de números complexos em C#. Cada elemento do primeiro número é multiplicado por cada elemento do segundo número, segundo a fórmula:

(a+bi)(c+di) = ac + adi + bci + bdi2

Vamos multiplicar os números 2 + 5i e 3 + 11i em C#. Para isso usaremos o método Multiply(num1,num2), que recebe como argumentos dois números complexos e retorna como resultado o produto entre eles:

Complex c1 = new Complex(2,5);
Complex c2 = new Complex(3, 11);
Complex c3 = Complex.Multiply(c1, c2);
Console.WriteLine("Produto: " + String.Format("{0} + {1}i", c3.Real, c3.Imaginary));

Exemplo 03: Agora vamos realizar uma subtração de números complexos. Para isso usaremos a operação Subtract(num1,num2), onde:

• num1 = primeiro número complexo a adicionar
• num2 = segundo número complexo a adicionar

A subtração de números complexos é realizada subtraindo-se cada parte separadamente, de acordo com a fórmula:

(a+bi) - (c+di) = (a-c) + (b-d)i

Vamos ao um exemplo. Iremos subtrair o valor 1 + 3i de 3 + 5i:

Complex c1 = new Complex(1,3);
Complex c2 = new Complex(3, 5);
Complex c3 = Complex.Subtract(c2, c1);
Console.WriteLine("Subtração: " + String.Format("{0} + {1}i", c3.Real, c3.Imaginary));

Exemplo 04: Vamos determinar o conjugado de um número complexo. Para isso, vamos empregar o método Conjugate(complex), que recebe como argumento um número complexo e retorna outro complexo como resultado.

O conjugado de um complexo é o número com o sinal trocado em sua parte imaginária. Vamos determinar o conjugado de 2 + 7i em C#:

Complex c1 = new Complex(1,3);
Complex conj = Complex.Conjugate(c1);
Console.WriteLine("Conjugado de {0}: {1}", String.Format("{0} + {1}i", c1.Real, c1.Imaginary), String.Format("{0} {1}i", conj.Real, conj.Imaginary));

O conjugado de um complexo é empregado, por exemplo, para auxiliar na operação de divisão entre números complexos, que será nosso próximo exemplo.

Exemplo 05: Finalmente, vamos efetuar uma divisão entre dois complexos em C#. Usaremos o método Divide(num1,num2) para realizar tal operação, o qual divide o complexo num1 pelo complexo num2.

Vamos realizar a seguinte divisão de complexos com C#:

Código:

Complex c1 = new Complex(5, 2);
Complex c2 = new Complex(7, 4);
Complex cDiv = Complex.Divide(c1,c2);
Console.WriteLine("Resultado da divisão: {0}", String.Format("{0} + {1}i", cDiv.Real, cDiv.Imaginary));

É isso aí! A estrutura Complex em C# possui inúmeros outros métodos que implementam operações matemáticas com números complexos, se sua documentação oficial por ser consultada aqui.

No próximo artigo vamos abordar algumas operações mais avançadas que podem ser realizadas com a estrutura Complex. Até!

O post Números Complexos em C# – Introdução apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Na lição anterior apresentamos o namespace SqlClient, e agora iremos criar uma string de conexão ao banco de dados usando este namespace.

Criar a string de conexão SQL

Primeiramente precisamos criar a string de conexão ao banco de dados desejado. Para isso, após importarmos a classe SqlClient por meio de uma diretiva using, criamos a string de conexão (que chamaremos de strConn), informando a fonte dos dados, nome do banco desejado e tipo de segurança, como podemos ver a seguir:

//... Diretivas using ...
using System.Data.SqlClient;

public partial class TelaPrincipal : Form
{
public string strConn;

public TelaPrincipal()
{
  InitializeComponent();
  strConn = ("Data Source=Boson-PC\\SQLEXPRESS;Initial Catalog=db_Biblioteca;Integrated Security=true");
}
//... Resto do código ...

Com a string de conexão criada, podemos agora efetuar a conexão de nossa aplicação a um banco de dados do SQL Server. Veremos como fazer isto na sequência.

Conectar ao Banco de Dados

Para efetuar a conexão ao banco de dados, criamos um objeto do tipo SqlConnection e o inicializamos passando como parâmetro a string de conexão criada:

SqlConnection conn = new SqlConnection(strConn);

Desta forma, criamos um objeto de nome conn, o qual contém a string de conexão strConn, declarada no início do código.

Para realizar a conexão ao banco de dados (abrir a conexão), basta agora chamar o método Open() do objeto SqlConnection criado:

conn.Open();

Se a conexão for realizada com sucesso será possível realizar operações no banco de dados indicado, como consultas ou inserções de dados. Veremos como realizar essas operações nas próximas lições deste minicurso.

Após realizar as operações desejadas no banco, é importante fechar a conexão, usando para isso o método Close():

conn.Close();

É isso aí! Agora que já sabemos como criar uma string de conexão e como conectar a aplicação ao banco de dados, podemos começar a realizar as operações desejadas no banco, como as operações CRUD (Create, Read, Update, Delete). Nos ocuparemos disso nos próximos artigos.

O post Criar string de conexão em C# com a classe SqlConnection e conectar a um banco de dados SQL Server apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Para que possamos prosseguir com nosso estudo sobre acesso a bancos de dados SQL Server com C# / Windows Forms, vamos precisar de um banco de dados pronto e com dados registrados. Iremos empregar o banco de dados db_Biblioteca, o qual já foi utilizado em nossos cursos de SQL Server e MySQL.

Para acelerar os estudos, temos aqui o código completo do banco, incluindo a criação de suas três tabelas e respectiva inserção de alguns registros. Basta executá-lo no SQL Server Management Studio.

Não se esqueça de criar uma pasta chamada “SQL” na raiz de seu computador (C:\SQL), ou se preferir usar outra pasta para armazenar o banco, altere o código da seção “Criar o banco” de acordo com o caminho de sua pasta.

Diagrama

A seguir temos o diagrama que mostra as tabelas do banco de dados que será criado (tbl_livros, tbl_autores e tbl_editoras):

Código

-- Criar o banco
CREATE DATABASE db_Biblioteca ON PRIMARY
(NAME = db_Biblioteca,
FILENAME = 'C:\SQL\db_Biblioteca.mdf',
SIZE = 6MB,
MAXSIZE = 15MB,
FILEGROWTH = 10%)
LOG ON (
NAME = db_Biblioteca_log,
FILENAME = 'C:\SQL\db_Biblioteca.ldf',
SIZE = 1MB, FILEGROWTH = 1MB)
GO

-- Criar Tabelas
USE db_Biblioteca;
CREATE TABLE tbl_autores (
ID_Autor SMALLINT PRIMARY KEY IDENTITY,
Nome_Autor VARCHAR(50),
Sobrenome_Autor VARCHAR(60)
)
GO
CREATE TABLE tbl_editoras
(ID_Editora SMALLINT PRIMARY KEY IDENTITY,
Nome_Editora VARCHAR(50)
)
GO
CREATE TABLE tbl_livros (
ID_Livro SMALLINT IDENTITY(100,1),
Nome_Livro VARCHAR (50) NOT NULL,
ISBN VARCHAR(30) NOT NULL UNIQUE,
ID_Autor SMALLINT NOT NULL,
Data_Pub DATE NOT NULL,
Preco_Livro MONEY NOT NULL,
ID_Editora SMALLINT NOT NULL
CONSTRAINT pk_id_livro PRIMARY KEY (ID_Livro),
CONSTRAINT fk_ID_Autor FOREIGN KEY (ID_Autor)
REFERENCES tbl_autores (ID_Autor) ON DELETE CASCADE,
CONSTRAINT fk_ID_Editora FOREIGN KEY (ID_Editora)
REFERENCES tbl_editoras (ID_Editora) ON DELETE CASCADE
)
GO

--Inserir dados na tabela de Autores
INSERT INTO tbl_Autores (Nome_Autor, SobreNome_Autor)
VALUES
('Daniel', 'Barret'),
('Gerald', 'Carter'),
('Mark', 'Sobell'),
('William', 'Stanek'),
('Richard', 'Blum')
GO
--Inserir dados na tabela de Editoras
INSERT INTO tbl_Editoras (Nome_Editora)
VALUES
('Prentice Hall'),
('O´Reilly'),
('Microsoft Press'),
('Wiley')
GO
--Inserir dados na tabela de Livros
INSERT INTO tbl_Livros (Nome_Livro, ISBN, Data_Pub, Preco_Livro, ID_Autor, ID_editora)
VALUES
('Linux Command Line and Shell Scripting',143856969,'20091221', 68.35, 5, 4),
('SSH, the Secure Shell',127658789,'20091221', 58.30, 1, 2),
('Using Samba',123856789,'20001221', 61.45, 2, 2),
('Fedora and Red Hat Linux', 123346789, '20101101', 62.24, 3, 1),
('Windows Server 2012 Inside Out',123356789,'20040517', 66.80, 4, 3),
('Microsoft Exchange Server 2010',123366789,'20001221', 45.30, 4, 3)
GO

-- Verificar se registros foram inseridos
SELECT * FROM tbl_livros;

Banco criado e com dados inseridos.

É isso aí! Na próxima lição vamos estudar o namespace SqlClient. Até!

O post Código do SQL Server do banco db_Biblioteca para C# apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

O namespace System.Data.SqlClient contém diversas classes e outros componentes que permitem realizar a interação com um banco de dados do SQL Server, a partir de uma aplicação em C#, permitindo assim o desenvolvimento de aplicações orientadas a dados. Ele é um Provedor de Dados .NET para o SQL Server (Data Provider).

Este namespace fornece uma grande variedade de funcionalidades, como por exemplo criação de conexões a bancos de dados, permitir a inserção de dados e a manipulação de registros. Ou seja, é um recurso essencial para a construção desse tipo de aplicação.

Para usar as classes disponíveis neste namespace é necessário declará-lo por meio de uma diretiva using na seção de namespaces do código da aplicação:

using System.Data.SqlClient;

Exemplos de classes comumente utilizadas do namespace SqlClient:

A lista completa de classes, enumerações e delegates do namespace System.Data.SqlClient pode ser consultada na página da documentação oficial da Microsoft.

Na próxima lição vamos explorar a criação de uma string de conexão a um banco de dados por meio do uso da classe SqlConnection.

Anterior: Código do SQL Server do banco db_Biblioteca para C#

O post Acesso a Banco de Dados SQL Server: o namespace SqlClient apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Nesta lição iremos estudar as Estruturas de Decisão Condicional em C#. Veremos como trabalhar com o Condicional Simples, com o Condicional Composto e também com o Condicional Encadeado.

Desvio Condicional Simples em C#

O desvio condicional simples tem por finalidade tomar uma decisão de acordo com o resultado de uma condição (teste lógico).

Se o teste lógico retorna o valor true, as instruções contidas no bloco delimitado por chaves { } serão executadas; caso contrário, nada ocorrerá.

Sintaxe:

if (teste lógico) {
   instruções a executar se teste lógico retornar true
}

A seguir temos um exemplo de utilização do condicional simples em C#:

// Condicional Simples:
int num1;
int num2;
Console.WriteLine("Digite um número:");
num1 = int.Parse(Console.ReadLine());
Console.WriteLine("Digite outro número:");
num2 = int.Parse(Console.ReadLine());
if (num1 == num2) {
   Console.WriteLine("Os números são iguais");
}

Desvio Condicional Composto em C#

O desvio condicional composto também tem por finalidade tomar uma decisão de acordo com o resultado de uma condição (teste lógico). Assim como no condicional simples, se o teste retorna verdadeiro, as instruções contidas no bloco if delimitado por chaves { } serão executadas. Porém, se o teste retornar false, as instruções contidas no bloco else é que serão executadas.

Sintaxe:

if (teste lógico) {
   instruções a executar se teste lógico retornar true
}
else {
   instruções a executar se teste lógico retornar false
}

Note que a palavra else deve vir imediatamente após a chave que fecha o bloco if, caso contrário será gerado um erro.

A seguir temos um exemplo de utilização do condicional composto em C#:

// Condicional Composto:
int num1;
int num2;
Console.WriteLine("Digite um número:");
num1 = int.Parse(Console.ReadLine());
Console.WriteLine("Digite outro número:");
num2 = int.Parse(Console.ReadLine());
if (num1 == num2) {
   Console.WriteLine("Os números são iguais");
}
else {
   Console.WriteLine("Os números são diferentes");
}

Desvio Condicional Encadeado em C#

O condicional encadeado é usado quando é necessário verificar condições sucessivas onde uma ação será executada se um conjunto anterior de ações for satisfeito. Usamos a combinação else if para criar testes encadeados (ou aninhados).

Sintaxe:

if (teste lógico #1) {
   instruções a executar se teste lógico retornar true
}
else if (teste lógico #2) {
   instruções a executar se teste lógico #1 retornar false
}
else {
 instruções a executar se ambos os testes lógicos retornarem false
}

Você pode encadear quantos blocos else if forem necessários. Note que o bloco else deve ser sempre a última instrução do conjunto (não pode vir antes de um else if).

A seguir temos um exemplo de utilização do condicional encadeado em C#:

// Condicional Encadeado:
int num1;
int num2;
Console.WriteLine("Digite um número:");
num1 = int.Parse(Console.ReadLine());
Console.WriteLine("Digite outro número:");
num2 = int.Parse(Console.ReadLine());
if (num1 > num2) {
   Console.WriteLine("num1 é maior que num2");
}
else if (num1 < num2) {
   Console.WriteLine("num1 é menor que num2");
}
else {
   Console.WriteLine("os númros são iguais");
}

Próximo: Estruturas de Repetição em C#

O post Desvio Condicional em C# – if / else if / else apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Existem várias técnicas que podem ser empregadas para colocar os elementos de um array em ordem (crescente ou alfabética). Por exemplo, em C#  podemos usar o método Array.Sort para ordenar o array, de forma simples e objetiva.

Porém, para fins didáticos, neste tutorial vou mostrar como implementar nosso próprio sistema de ordenação de elementos de um array, usando o método Bubble Sort em C#, e no final do artigo também mostrarei como usar o método Array.Sort para ordenar o conteúdo de um array.

O projeto

Vamos criar um novo projeto no Visual Studio e acrescentar dois botões e dois labels (podem ser listboxes, se você preferir). Daremos os seguintes nomes aos componentes:

• Botão bntOrdenaArray – Botão que ao ser clicado, coloca o conteúdo do array e ordem e o exibe em um label ou listbox
• Botão bntMostraArray – Botão que exibe o conteúdo do array criado antes de ser ordenado.
• Label lblOriginal – Label que exibe o conteúdo do array antes da ordenação.
• Label lblOrdenado – Label que mostra o conteúdo do array após a ordenação.

Código

A listagem a seguir traz o código completo da aplicação, para cada componente:

namespace bubblesort
{
 public partial class Form1 : Form
 {
   int[] x = { 2, 1, 8, 7, 5, 9, 15, 3, 6 };
   public Form1()
   {
     InitializeComponent();
   }
 // criando o método bubblesort
   public void bubblesort(int[] y)
   {
     for (int i = 1; i < y.Length; i++)
       for (int j = 0; j < y.Length - 1; j++)
          if (y[j] > y[j + 1])
            troca(y, j);
   }
 // algoritmo de troca de valores de variáveis:
   public void troca(int[] g, int primeiro)
   {
     int aux;
     aux = g[primeiro];
     g[primeiro] = g[primeiro + 1];
     g[primeiro + 1] = aux;
   }
   private void btnOrdenaArray_Click(object sender, EventArgs e) // Botão para ordenar o array
   {
     // Ordenando e exibindo o array:
     bubblesort(x);
     lblOrdenado.Text = "Itens do array ordenados:\n";
     for (int i = 0; i < x.Length; i++)
     {
        lblOrdenado.Text += " " + x[i];
     }
   }
   private void btnMostraArray_Click(object sender, EventArgs e) // Botão para mostrar conteúdo original do array
   {
     lblOriginal.Text = "Itens do array na ordem original:\n";
     for (int i = 0; i < x.Length; i++)
     {
       lblOriginal.Text += " " + x[i];
     }
   }
 }
}

A figura a seguir mostra nosso programa em execução, trazendo o array original e seu conteúdo ordenado com o método Bubble Sort:

O método Array.Sort()

Para usar o método Array.Sort() basta passar o array contendo os itens a serem ordenados como parâmetro do método.  Por exemplo, você pode acrescentar mais um botão e um label na aplicação anterior, e usar o código a seguir para realizar a ordenação do conteúdo do array:

 private void btnArraySort_Click(object sender, EventArgs e)
 {
   Array.Sort(x);
   lblArraySort.Text = "Itens do array ordenados:\n";
   foreach (int item in x)
   {
     lblArraySort.Text += " " + item.ToString();
   }
 }

Muito mais simples não? Mas é claro que é muito importante saber criar seus próprios algoritmos para manipulação de estruturas de dados, por isso ensinamos neste tutorial a implementar seu próprio Bubble Sort. Mas na prática procure sempre utilizar clases e métodos já existentes, em ves de “reinventar a roda”.

É isso ai! Até a próxima!

Veja também: Ordenação de Arrays em C com o método Bubblesort

O post Ordenação de Arrays com método Bubble Sort em C# apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Classe Random

A classe random, pertencente ao namespace System, nos permite gerar números aleatórios em C# por meio de seus métodos, incluindo números inteiros e de ponto flutuante. Números aleatórios são empregados em diversas aplicações, tais como criptografia, simulações estatísticas e jogos de computador.

Como usar a classe random

Primeiramente, instanciamos a classe:

Random numAleatorio = new Random();

E então invocamos um de seus métodos geradores de números aleatórios, atribuindo o retorno do método a uma variável de tipo compatível.

Gerando número aleatório inteiro

Para gerar um número aleatório inteiro, usamos o método Next(), que permite gerar um valor inteiro (int) positivo entre zero e Int32.MaxValue (2.147.483.647).

int valorInteiro = numAleatorio.Next();

Podemos também configurar o intervalo de números gerados adicionando dois argumentos ao método Next(): número inicial e número final + 1. Por exemplo, para gerar apenas números aleatórios entre 1 e 20, escrevemos:

int valorInteiro = numAleatorio.Next(1,21);

Gerando número aleatório de ponto flutuante:

E para gerar um número de ponto flutuante, usamos o método NextDouble():

double valorDecimal = numAleatorio.NextDouble();

Note que o método NextDouble() gera um número do tipo double, e não um float.

Visualizando os valores gerados

Para ver os valores aleatórios gerados, basta exibir o conteúdo das variáveis utilizadas em umca caixa de texto, label ou outro componente compatível. O código a seguir, associado a um botão em um formulário, permite gerar e exibir os valores (inteiro e decimal) em dois labels:

private void btnGeraNumero_Click(object sender, EventArgs e)
 {
     Random numAleatorio = new Random();
     int valorInteiro = numAleatorio.Next(10,21);
     double valorQuebrado = numAleatorio.NextDouble();
     lblNumeroIntGerado.Text = valorInteiro.ToString();
     lblNumDoubleGerado.Text = valorQuebrado.ToString();
 }

Ao executar o programa e clicar no botão, teremos uma saída como a seguinte:

O post Como gerar números aleatórios com C# apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um controle ColorDialog é utilizado para selecionar uma cor de uma paleta de cores disponível, e também para definir cores personalizadas. Essas cores podem então serem aplicadas em outros objetos do formulário, dinamicamente.

É possível criar um controle ColorDialog usando o designer de formulários durante o design da aplicação, ou então usando a classe ColorDialog no código em tempo de execução (runtime), dinamicamente.

Modo de Design

Para criar um ColorDialog em modo de design, simplesmente arraste o controle apropriado para um form. Você encontrará o ColorDialog na Toolbox -> Dialogs:

Modo Run-time

Para criar um controle a ColorDialog em tempo de execução basta criar uma instância da classe ColorDialog, ajustar suas propriedades e adicionar a classe aos controles do Form.

Primeiro criamos a instância da classe ColorDialog. O trecho de código a seguir permite criar um objeto de controle ColorDialog de nome cdgCaixaCores:

ColorDialog cdgCaixaCores = new ColorDialog();

A seguir temos algumas das propriedades que podem ser cofiguradas no controle em runtime:

• AllowFullOpen – Habilitar ou desabilitar o botão Definir Cores Personalizadas
• Color – A cor selecionada no controle.
• FullOpen – O valor true significa que a seção Definir Cores Personalizadas será exibida por padrão ao abrir o ColorDialog.
• SolidColorOnly – Indica se a caixa restringirá a escolha de cores sólidas pelos usuários.
• AnyColor – Se a caixa mostrará todas as cores definidas no conjunto de cores básicas.

Exemplos de configuração dessas propriedades:

cdgCaixaCores.AnyColor = true; // Caixa mostra todas as cores definidas
cdgCaixaCores.SolidColorOnly = false; // Usuário poderá escolher cores não sólidas
cdgCaixaCores.Color = Color.Red; // Cor vermelha selecionada no controle.

Usando o controle ColorDialog

Crie um novo projeto para Windows Forms no Visual Studio e insira no formulário os seguintes controles:

• Botão com propriedade Name igual a btnCorFundo; Texto: Cor de Fundo
• Botão com propriedade Name igual a btnCorTexto; Texto: Cor do Texto
• ColorDialog com propriedade Name igual a cdgCaixaCores
• TextBox com propriedade Name igual a txtCores; Fonte tamanho 16.

Veja nosso projeto na figura a seguir:

Vamos programar os botões:

// Evento Click do Botão Cor de Fundo - usando o controle da ToolBox:
if (cdgCaixaCores.ShowDialog() == DialogResult.OK)
{
  txtCores.BackColor = cdgCaixaCores.Color;  // Muda a cor de fundo da caixa de texto.
}
// Evento Click no Botão Cor do Texto (criando um ColorDialog dinamicamente e configurando):
ColorDialog cdgCores2 = new ColorDialog();
cdgCores2.AllowFullOpen = false;
cdgCores2.AnyColor = true;
cdgCores2.SolidColorOnly = false;
cdgCores2.Color = Color.Blue;
if (cdgCores2.ShowDialog() == DialogResult.OK)
{
  txtCores.ForeColor = cdgCores2.Color;  // Alterando a cor do texto digitado na caixa de texto
}

Para testar, execute o programa, digite uma frase na caixa de texto e clique nos botões para alterar a cor de fundo e de fonte, selecionadas no caixa de diálogo de cores:

1 – Abrindo o programa e digitando uma frase na caixa de texto:

2 – Clique no botão Cor de Fundo para selecionar uma cor para o background da caixa de texto:

3 – Após selecionar a cor e clicar em OK, a cor será aplicada ao fundo da caixa de texto. Clique então no botão Cor do Texto para selecionar uma cor para a frase digitada:

4 – Clique em OK na caixa de diálogo de cor e verifique que a formatação desejada foi aplicada na caixa de texto:

É isso aí! No próximo tutorial vamos aprender a utilizar mais controles para Windows Forms. Até!

O post Curso de C# – Classe ColorDialog – Selecionando cores em uma paleta apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.