Temos outras funções para trabalhar com strings, como a Replace (que substitui algo na string), e a Concat da classe String, que concatena algo. Veja o uso delas:
string frase = "Isso é uma String";
Console.WriteLine(frase.Replace("String", "Frase")); // Substitui algo
Console.WriteLine(String.Concat(frase, " e ela foi concatenada!")); // Concatena com mais algo
Para inverter strings, usamos o método Reverse da classe Array, mas antes temos que converter a string para array de char, assim:
string frase = "Isso é uma String";
char[] novo = frase.ToCharArray(); // Converte string pra array de char
Array.Reverse(novo); // Inverte
Console.WriteLine(new String(novo)); // Converte novamente para string
Para remover espaços desnecessário de strings, basta usar o Trim, assim:
string texto = " Exemplo de String! ";
Console.WriteLine(texto.Trim());
Para transformar todas as letras em maiúsculas e minúsculas, use os métodos ToUpper() e ToLower() do objeto, respectivamente:
string frase = "Isso é uma String";
Console.WriteLine(frase.ToUpper()); // Converte pra maiúscula
Console.WriteLine(frase.ToLower()); // Converte pra minúscula
Para comparar strings, ao invés do ==, use o método Equals(), assim:
string texto1 = "Microsoft";
string texto2 = new string("Microsoft".ToCharArray());
Console.WriteLine(texto1.Equals(texto2));
Para encontrar se uma palavra existe na string, faça assim:
string frase = "Isso é uma String";
int posicao = frase.IndexOf("String");
if(posicao != -1) {
Console.WriteLine("Palavra encontrada.");
}
else {
Console.WriteLine("Palavra não encontrada.");
}
Para ver se uma string está vazia, use o método IsNullOrEmpty() do objeto, assim:
string nome = "";
Console.WriteLine("Nome está vazio ou nulo? " + string.IsNullOrEmpty(nome));
Para ver a quantidade de caracteres de uma string, use o atributo Length do objeto, assim:
string frase = "Exemplo de String";
Console.WriteLine("Quantidade de caracteres: " + frase.Length);
Para dividir uma string ao encontrar um delimitador, podemos fazer assim:
string frase = "Exemplo de Frase";
string[] dividido = frase.Split(' '); // Pode ser qualquer caractere.
Console.WriteLine(dividido[0]);
Os operadores de atribuição são usados para atribuir um valor à uma variável. O operador é um =, mas temos também operadores de atribuição com operações aritméticas, como o += (que é um acumulador, que soma valores à variável), da mesma forma age os operadores-=, *= e /=, que fazem a atribuição com a operação.
Veja um exemplo abaixo:
using System;
namespace OperadoresAtribuicaoIncrementoEDecremento {
class Program {
static void Main(string[] args) {
int var1;
var1 = 50;
Console.WriteLine("Atribuição: {0}", var1);
var1 += 20; // Seria o mesmo que var1 = var1 + 20
Console.WriteLine("Acumulando: {0}", var1);
var1 *= 2; // Seria o mesmo que var1 = var1 * 2
Console.WriteLine("Multiplicando: {0}", var1);
Console.ReadLine();
}
}
}
PS: Note que usamos uma exibição diferente no WriteLine(), como se fosse um print formatado.
Para formatar valores float, faça assim, colocando a quantidade de casas com zeros:
float real = 12345.6789f;
Console.WriteLine("{0:0.00}", real);
Podemos também usar isso no método String.Format(), que pode ser usado em Windows Forms, por exemplo.
Os operadores de incremento e decremento são usados para aumentar e diminuir valores de um em um, e podem ser usados o pré e o pós, dependendo da necessidade.
Veja um exemplo abaixo:
using System;
namespace OperadoresAtribuicaoIncrementoEDecremento {
class Program {
static void Main(string[] args) {
int contador;
contador = 50;
Console.WriteLine(contador); // Executa normal
Console.WriteLine(contador++); // Executa e incrementa depois
Console.WriteLine(contador); // Executa já incrementado.
Console.ReadLine();
}
}
}
No caso acima, seria mais correto fazer o pré-decremento, assim:
Console.WriteLine(contador); // Executa normal
Console.WriteLine(++contador); // Incrementa e executa após isso
Console.WriteLine(contador); // Executa já incrementado.
Da mesma forma acima, o decremento é usado.
Um operador booleano é um operador que realiza um cálculo cujo resultado pode ser true ou false. Em C# há vários operadores booleanos, que podem ser classificados em dois tipos distintos, operadores relacionais e de igualdade e e operadores condicionais lógicos
Esses são os operadores relacionais e de igualdade:
| Operador Aritmético | Significado |
|---|---|
| == | Igualdade. |
| != | Diferente. |
| > | Maior. |
| < | Menor. |
| >= | Maior ou Igual. |
| <= | Menor ou Igual. |
Em alguns casos, o igual não compara dois tipos de conteúdos, como por exemplo, objetos, sendo necessário usar o método Equals() desses mesmos objetos.
PS: Podemos também colocar atribuição com algum valor, como por exemplo num += 2 ou num -= 3, que faça a atribuição e a operação juntos no mesmo comando. Concatenação com atribuição também pode ser colocada com o +=.
Os operadores lógicos permitem combinar expressões ou valores booleanos e retornar um resultado lógico:
Esse são os operadores lógicos usados em C#:
| Operador | Operação | Significado |
|---|---|---|
| && | AND | E |
| || | OR | Ou |
| ! | NOT | Não |
| ^ | XOR | Ou Exclusivo |
Veja um exemplo abaixo do uso de NOT:
using System;
namespace OperadoresLogicosERelacionais {
class Program {
static void Main(string[] args) {
bool valor;
valor = true;
valor = !valor; // Inversão
Console.WriteLine(valor.ToString()); // Retorna false
Console.ReadLine();
}
}
}
Veja um exemplo de uso de AND:
using System;
namespace OperadoresLogicosERelacionais {
class Program {
static void Main(string[] args) {
int idade;
bool valida;
Console.Write("Digite sua idade: ");
idade = int.Parse(Console.ReadLine());
valida = (idade > 0) && (idade <= 120);
Console.WriteLine(valida.ToString());
Console.ReadLine();
}
}
}
Veja um exemplo do uso de OR:
using System;
namespace OperadoresLogicosERelacionais {
class Program {
static void Main(string[] args) {
int temperatura;
bool invalida;
Console.Write("Digite a temperatura em graus Celsius para ver se a água está nos estados sólido ou gasoso: ");
temperatura = int.Parse(Console.ReadLine());
invalida = (temperatura < 0) || (temperatura > 100);
Console.WriteLine(invalida.ToString());
Console.ReadLine();
}
}
}
PS: Note que nos dois métodos acima, usamos o método Console.ReadLine() para pegar dados de entrada do teclado.
Também temos o operador ternário em C#:
using System;
namespace OperadoresLogicosERelacionais {
class Program {
static void Main(string[] args) {
Console.Write("Digite sua idade: ");
int idade = int.Parse(Console.ReadLine());
string maior = (idade >= 18) ? "É de Maior!" : "É de Menor!";
Console.WriteLine(maior);
Console.ReadLine();
}
}
}
Como sabemos, o condicional simples é usada para testar condições e determinar as ações a seguir de acordo com o resultado do teste, contendo apenas o if.
O condicional composto contém o if e o else, que executa um código se a expressão do if for verdadeira, caso contrário ele executará o código do else.
Veja um exemplo de condicional simples em C#:
using System;
namespace EstruturasCondicionaisSimplesEComposta {
class Program {
static void Main(string[] args) {
int num1;
int num2;
Console.Write("Digite um número: ");
num1 = int.Parse(Console.ReadLine());
Console.Write("Digite outro número: ");
num2 = int.Parse(Console.ReadLine());
if(num1 == num2) {
Console.Write("Os números " + num1 + " e " + num2 + " são iguais!");
}
Console.Read();
}
}
}
Da mesma forma, para criar um condicional composto, basta colocar o else abaixo do if, ele automaticamente é relacionado à chave do último if:
if(num1 == num2) {
Console.Write("Os números " + num1 + " e " + num2 + " são iguais!");
}
else {
Console.Write("Os números " + num1 + " e " + num2 + " são diferentes!");
}