Blog da Hostweb » C#

Enviando emails usando C#

Bruno Sabóia — Wed, 23 Dec 2009 15:22:41 +0000

Olá, garotada. O post de hoje tratará de um assunto mais simples, porém bastante necessário e básico na rotina atual de programação: envio de emails.

Com a popularização da internet, o email passou a ser um meio de comunicação extremamente difundido. As linguagens mais antigas, como C, não possuem um suporte tão cristalino ao envio de mensagens como as atuais. É claro que é possível fazê-lo, mas nas linguagens atuais é mais fácil.

Linguagens totalmente voltadas ao desenvolvimento web, como Ruby e PHP, tem um ótimo suporte ao envio de emails. O C# se encontra em uma situação intermediária, mas não é nada assustador.

As classes de envio de email se encontram no namespace System.Net.Mail, disponível no framework 2.0 em diante.

Começamos colocando o remetente e o destinatário da mensagem. Isso é simples de se fazer:

MailAddress from = new MailAddress(”brunosaboia@hostweb.com.br”);
MailAddress to = new MailAddress(”leitor@hostweb.com.br”);

Simples, não? Agora, podemos criar a nossa MailMessage para enviar o email:

MailMessage message = new MailMessage(from, to);

Agora, já temos o objeto da nossa mensagem. Mas uma mensagem sem assunto, sem conteúdo e sem ser enviada… bem, não é exatamente o meu conceito de mensagem.

message.Subject = “Olá, caro leitor”;
message.Body = “Gostaria de desejar um feliz natal a você e sua família!”;

Pronto, assim está melhor. Temos um destinatário, um remetente, um assunto e um conteúdo. Agora podemos chamá-la de mensagem, não? Porém, se não a enviarmos, ela ainda não terá cumprido seu objetivo, e será uma mensagem triste e derrotada. Vamos ajudá-la:

try
{
client.Send(message);
Console.WriteLine(”Mensagem enviada com sucesso!”);
}
catch (Exception ex)
{
Console.WriteLine(”Erro ao enviar: {0}”, ex.ToString());
}

Se tudo ocorrer bem, a mensagem será enviada e você terá desejado feliz natal a alguém.

Segue abaixo o código completo:

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Mail;

namespace MailTest
{
class Program
{
static void Main(string[] args)
{
MailAddress from = new MailAddress(”brunosaboia@hostweb.com.br”, “Bruno Saboia”);
MailAddress to = new MailAddress(”leitor@hostweb.com.br”, “Leitor do Blog”);
MailMessage message = new MailMessage(from, to);

message.Subject = “Olá, caro leitor”;
message.Body = “Gostaria de desejar um feliz natal a você e sua família!”;

string smtpHost = “smtp.hostweb.com.br”;
SmtpClient client = new SmtpClient(smtpHost);

try
{
client.Send(message);
Console.WriteLine(”Mensagem enviada com sucesso!”);
}
catch (Exception ex)
{
Console.WriteLine(”Erro ao enviar a mensagem: {0}”, ex.ToString());
}

}
}
}

Espero que tenham gostado. Feliz natal, e até a próxima!

Enum em C#

Bruno Sabóia — Thu, 17 Dec 2009 13:40:17 +0000

Olá a todos novamente. O tópico de hoje tratará de enums, uma estrutura herdada do C e presente em várias linguagens de programação.

A utilidade dos enums está em organizar tipos de dados sequenciais. Dias da semana são um ótimo exemplo. Os enums servem para enumerar estados, também (conectado, desconectado, em espera, por exemplo).
Observe abaixo como declarar um enum com os dias da semana:

enum Dias { Dom, Seg, Ter, Qua, Qui, Sex, Sab };

Nada de muito fantástico, não é? Há um detalhe aqui. O enum Dom começa com 0 – é o default do C#. Seg seria 1, Ter 2, e assim por diante. Mas adivinhe se podemos mudar essa lógica? Isso mesmo, podemos. E é simples. Podemos fazer:

enum Dias { Dom=1, Seg, Ter, Qua, Qui, Sex, Sab };

Isso faria com que Seg fosse 2, Ter 3, e assim por diante.

A classe Enum (com E maiúsculo) fornece alguns métodos interessantes. Observe o código abaixo:

using System;
using System.Collections.Generic;

namespace EnumTest
{

class Program
{
enum Dias { Dom=1, Seg, Ter, Qua, Qui, Sex, Sab };
static void Main(string[] args)
{
foreach (string dia in Enum.GetNames(typeof(Dias)))
{
Console.WriteLine(dia);
}
foreach (int i in Enum.GetValues(typeof(Dias)))
{
Console.WriteLine(i);
}
Console.ReadLine();
}
}
}

Com isso, listamos o nome e os valores de todos os itens da nossa enum dos dias da semana.

Há também a possibilidade de mudar o tipo base do enum, bem como criar flags com essa estrutura. Isso fica como dever de casa para a criançada.

Obrigado, e espero que tenham gostado. Até a próxima!

Um pouco sobre LINQ

Bruno Sabóia — Thu, 03 Dec 2009 11:21:37 +0000

Olá a todos novamente. Esse post tratará sobre LINQ (que quer dizer Language Integrated Query, ou Linguagem de Consulta Integrada). Você pode usar os nossos conhecidos amigos “select”, “where” e “from” do SQL nativamente no código C# ou VB. Essa poderosa ferramenta permite que você trate objetos da mesma maneira como trataria resultados de uma consulta ao banco.

Um exemplo básico de código:

using System;
using System.Linq;
using System.Collections.Generic;

class LinqTeste {
static void Main() {
string[] nomes = { “Bruno”, “Sérgio”, “Giordano”,
“Eduardo”, “Robson”, “Pablo”,
“Lino”, “Lyanderson” };

IEnumerable query = from s in nomes
where s.Length > 4
orderby s
select s.ToUpper();

foreach (string nome in query)
Console.WriteLine(nome);
}
}

Esse código imprimirá na console todos os nomes cujo tamanho seja maior que 4 (excluindo, portanto, apenas nosso amigo Lino), ordenando-os por ordem alfabética.

Na verdade, a grande sacada do LINQ reside em que podemos abstrair se estamos lidando com um banco ou com objetos – a única diferença é a origem dos dados, não como os tratamos. No caso do exemplo, usamos um array de strings como nossa geratriz de dados, mas isso poderia muito bem ser gerado a partir de uma consulta a um banco.

Além disso, a maioria dos desenvolvedores que já trabalharam com SQL, independente da linguagem em que desenvolvessem, conhecessem os comandos básicos do LINQ. Isso torna mais fácil entender o código, mesmo pra quem não conhece muito bem a sintaxe do C# ou do VB.net.

Espero que tenham gostado desse breve esclarecimento sobre LINQ. Até a próxima!

Active Directory com C#

Bruno Sabóia — Wed, 25 Nov 2009 19:07:44 +0000

Uma das coisas mais fascinantes do framework .NET é a sua integração com alguns serviços do Windows. Trataremos de um deles nesse post de inauguração: o Active Directory.

O serviço de domínio da Microsoft, carinhosamente chamado de AD, possui ferramentas poderosas para o gerenciamento de diretórios, sejam eles pequenos ou corporativos. A arquitetura do AD abrange LDAP (Lightweight Directory Access Protocol, ou Protocolo Leve de Acesso a Diretório), autenticação Kerberos (usada para autenticação nas máquinas) e alguns serviços de DNS. Com ele, é possível gerenciar políticas de rede de maneira avançada. Mas o foco do post não é falar sobre o AD em si, e sim como usar o C# para tirar proveito dessa mecânica.

Em primeiro lugar, vamos criar um método para listar todos os domínios da árvore em que o computador está logado. Lembrando que devemos estar conectados ao diretório do AD para podermos realizar pesquisas.

O código do método pode ser algo do tipo:

public static List EnumerateDomains()
{

List lDomain = new List();

Forest forLocalForest = Forest.GetCurrentForest();

DomainCollection dcDomains = forLocalForest.Domains;

foreach (Domain objDomain in dcDomains)
{
lDomain.Add(objDomain);
}

return lDomain;

}

OK, nada demais até aí. Estamos criando uma lista de domínios, requisitando a floresta atual e pegando os domínios desta floresta, depois devolvemos tudo na lista. Mas nós não temos nada de útil por enquanto. Podemos pegar informações mais relevantes. Esse código de console nos devolveria algumas informações úteis sobre o domínio atual que nossa máquina está conectada.

O primeiro passo é a se fazer é aumentar o buffer do console, pois em um domínio vão existir muitos usuários e às vezes não será possível imprimir tudo na tela sem aumentar o espaço.

Console.BufferHeight = Int16.MaxValue – 1;

Em seguida, vamos enumerar os domínios:

try
{
Console.WriteLine(”Enumerando domínios . . .\n”);

foreach (Domain d in EnumerateDomains())

{
Console.WriteLine(string.Format(”Nome do domínio:{0}”, d.Name));
}
}

Isso mostrará o nome de todos os domínios disponíveis na rede.

Vamos agora imprimir algumas informações sobre o DC (Domain Controller, ou Controlador de Domínio):

Console.WriteLine(” * Algumas informações sobre os controladores de domínio…”);

foreach (DomainController dc in d.DomainControllers)
{
Console.WriteLine(string.Format(”\n\tNome do DC: {0}\n\tSistema Operacional do DC: {1}\n\tIP do DC: {2}\n\tHora e data atual do DC: {3}”, dc.Name, dc.OSVersion, dc.IPAddress, dc.CurrentTime.ToString(”dd/MM/yyyy HH:mm:ss”)));
Console.WriteLine(”\n * Algumas informações sobre as roles do DC…\n”);

foreach (ActiveDirectoryRole adr in dc.Roles)
{
Console.WriteLine(”\t” + adr.ToString());
}
}

Esse código irá mostrar o nome, o sistema operacional, o IP e a hora e data atual do DC. Logo em seguida, irá mostrar as roles do DC.

No final, iremos mostrar todos os usuários criados nesse DC. O código é assim:

Console.WriteLine(”\n * Enumerando usuários do DC…”);
DirectoryEntry group = new DirectoryEntry(”LDAP://” + dc.IPAddress);
DirectorySearcher src = new DirectorySearcher(group, “(objectCategory=user)”);

foreach (SearchResult res in src.FindAll())
{
Console.WriteLine(”\t” + res.Properties["name"][0]);
}

Pronto, agora nós já temos alguma informação relevante sobre o DC. O código completo do projeto segue abaixo:

using System;
using System.Collections.Generic;
using System.Text;
using System.DirectoryServices;
using System.DirectoryServices.ActiveDirectory;

namespace AD_Test
{
class Program
{

static void Main(string[] args)
{
Console.BufferHeight = Int16.MaxValue – 1;
try
{
Console.WriteLine(”Enumerando domínios . . .\n”);

foreach (Domain d in EnumerateDomains())
{
Console.WriteLine(string.Format(”Nome do domínio:{0}”, d.Name));
Console.WriteLine(” * Algumas informações sobre os controladores de domínio…”);

foreach (ActiveDirectoryRole adr in dc.Roles)
{
Console.WriteLine(”\t” + adr.ToString());
}

foreach (SearchResult res in src.FindAll())
{
Console.WriteLine(”\t” + res.Properties["name"][0]);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(string.Format(”Erro ao tentar enumerar domínios: {0}”, ex.Message));
}

Console.WriteLine(”\nEnumeração concluída”);
Console.Read();

}

public static List EnumerateDomains()
{
List lDomain = new List();
Forest forLocalForest = Forest.GetCurrentForest();
DomainCollection dcDomains = forLocalForest.Domains;

foreach (Domain objDomain in dcDomains)
{
lDomain.Add(objDomain);
}

return lDomain;
}
}
}

Espero que tenham gostado. Até a próxima, e cuidado para não quebrar seu servidor de domínio, alguém pode ficar com raiva.