terça-feira, 9 de janeiro de 2007

XML Notepad 2007 - Navegando e Editando documentos XML - Editor XML Gratuito

C# (pronunciada “C Sharp”), é uma nova linguagem de programação, da Plataforma .NET, derivada de C/C++,  simples, moderna, orientada à objetos e fortemente tipada(type-safe). C# possui o poder do C/C++ aliado a alta produtividade do Visual Basic.

C#  será distribuido juntamente com Microsoft Visual Studio 7.0(Visual Studio.NET), e providenciará acesso a toda a plataforma do Next Generation Windows Services(NGWS), que incluem uma poderosa biblioteca de classes e um mecanismo de execução comum.

C# é a linguagem nativa para .NET Common Language Runtime(CLR), mecanismo de execução da plataforma .NET. Isso possibilita a convivência com várias outras linguagens especifícadas pela Common Language Subset(CLS). Por exemplo, uma classe base pode ser escrita em C#, derivada em Visual Basic e novamente derivada em C#.

Objetivos da linguagem 

  • Primeira linguagem “orientada à componentes” da família C/C++:

    • .NET Common Language Runtime é um ambiente baseado em componentes, e C# é desenhado para facilitar a criação de componentes. Os conceitos de componentes, como propriedades, métodos, eventos e atributos, são fortemente aplicados. Documentação pode ser escrita dentro dos componentes e exportadas para XML.

    • C# não requer a bibliotecas de tipo(type libraries),  arquivos de cabeçalho(header files), arquivos IDL(IDL files). Os componentes criados em C#, são auto-descritivos e não necessitam de processo de registro. 

  • Tudo é objeto

    • Em C#, ao contrário de linguagens como Java ou C++, tipos de dados e objetos interagem. C# fornece um “sistema unificado de tipos”, onde todos os tipos são tratados como objetos, sem perda de performance,  ao contrário de linguagens como Lisp ou Smalltalk. 

  • Próxima geração de softwares robustos e duráveis

    • Software robusto e durável é uma necessidade básica. Muitas aplicações são dificeis de depurar e algumas vezes trazem resultados inesperados em tempo de execução.

    • Coletor de Lixo(Garbage Collection) que fornece gerenciamento automatico de memória, Excessões(Exceptions) que dispara erros que podem ser tratados, Segurança no tipo de dados (Type-safety) que assegura a manipulação de variáveis e casts e Versão(Versioning), são a recursos encontrados na linguagem para construção dessa categoria de software. 

  • Preservar seu  investimento

    • C# é montado sobre a “herança” do C++, isso torna confortável a adaptação do programador C++. C# possibilita utilização de ponteiros, na execução de código não gerenciado.

    • C# permite interoperabilidade com XML, SOAP, componentes COM, DLL e qualquer outra linguagem da Plataforma .NET, matendo integração total com projetos existentes.

    • Milhões de linhas de código, em C#, são encontradas no .NET, isso permite uma rápida curva de aprendizado e aumento de produtividade.

Next Generation Windows Services(NGWS) SDK

Para utilizar as classes base da plataforma .NET, o ambiente de execução, documentação e o compilador de C#, é necessário instalar o NGWS SDK que pode ser encontrado em http://msdn.microsoft.com/code/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml.

Windows 2000 (incluindo IIS) e Internet Explorer 5.5 são requiridos nesta instalação.

Primeiro programa

Escrevendo o tradicional programa Hello World, em C#:

using System;

 

class Hello{ 

  public static void Main(){ 

    Console.WriteLine("Hello World!!!"); 

  } 

}

Digite o código acima no seu editor de texto favorito e grave-o com o nome de Hello.cs. Para compilar o exemplo acima, no prompt, digite csc Hello.cs. Execute o programa digitando Hello. Figura 1, mostra compilação e execução da aplicação em C#: 

Figura 1: Compilação e Execução do programa em C#

Algumas considerações sobre o código do programa. A claúsula using referencia a as classes a serem utilizadas, System atua como namespace das classes. O namespace System contém muitas classes, uma delas é a Console. O método WriteLine, simplesmente emite a string no console.

Main

O método Main é o ponto de entrada de execução seu programa. No C# não existem funções globais, a classe que será executada inicialmente possui embutida a função estática Main. Uma ou mais classe pode conter a função Main, portanto apenas uma será o ponto de entrada, indicada na compilação pelo parametro /main:<tipo>, ou simplificando /m:<tipo>.

O método Main, pode ser declarado de 4 formas: 

  • Retornando um vazio(void):

    • public static void Main()

  • Retornando um inteiro(int):

    • public static int Main()

  • Recebendo argumentos, através de um array de string e retornando um vazio:

    • public static void Main(string[] args)

  • Recebendo argumentos, através de um array de string e retornando um inteiro:

    • public static int Main(string[] args)  


Estrutura de um programa

O esqueleto de um programa em C#, apresentando alguns dos seus elementos mais comuns, segue abaixo:

//Estrutura do programa em C#

using System;

namespace MathNamespace{
  public class MathClass{
    /*
     Main
     Exibe no prompt
    */
    public static void Main(string[] args){    
      Math m = new Math();
      Console.WriteLine(m.Sum(1,1));
    }
    //<summary>Classe Math</summary>
    public class Math:Object{
      public int Sum(int a, int b){
        return (a+b);
      }
    }
  }
}

A estrutura de um programa em C#, pode ser dividida em um ou mais arquivos,  e conter:
  • Namespaces;

  • Tipos - classes, estruturas, interfaces, delegações, enums;

  • Membros – constantes, campos, métodos, propriedades, indexadores, eventos, operadores, construtores;

  • Outros - coméntarios, instruções.

Conclusão

Neste artigo, conhecemos qual as caracteristicas da linguagem C# e sua estrutura. Também foi destacado a necessidade do NGWS SDK, que contém o .NET Framework e seus compiladores. Um programa tradicional foi montado, compilado e executado.

Para saber mais. Links: 

http://msdn.microsoft.com/library/default.asp?URL=/library/welcome/dsmsdn/deep07202000.htm
http://msdn.microsoft.com/vstudio/nextgen/default.asp
http://www.microsoft.com/net/default.asp
http://msdn.microsoft.com/voices/csharp01182001.asp

Artigo de: Fabio R. Galuppo.

Classe de controle de CPF (Inclusive validação)

public class CPF
{
private string _cpf;
public string Cpf
{
get { return _cpf; }
set { _cpf = value; }
}

public override string ToString()
{
return _cpf;
}

private static string GerarDigito(string cpf)
{
int Peso = 2;
int Soma = 0;

for (int i = cpf.Length-1; i >= 0; i--)
{
Soma += Peso * Convert.ToInt32(cpf[i].ToString());
Peso++;
}

int pNumero = 11 - (Soma %11);

if (pNumero > 9)
pNumero = 0;

return pNumero.ToString();
}

public static bool Validar(string cpf)
{
// Se for vazio
if (String.IsNullOrEmpty(cpf.Trim()))
return false;

// Retirar todos os caracteres que não sejam numéricos
string aux = string.Empty;
for (int i = 0; i < cpf.Length; i++)
{
if (char.IsNumber(cpf[i]))
aux += cpf[i].ToString();
}

// O tamanho do CPF tem que ser 11
if (aux.Length != 11)
return false;

// Guardo o dígito para comparar no final
string pDigito = aux.Substring(9, 2);
aux = aux.Substring(0, 9);

//Cálculo do 1o. digito do CPF
aux += GerarDigito(aux);

//Cálculo do 2o. digito do CPF
aux += GerarDigito(aux);

return pDigito == aux.Substring(9, 2);
}

public static string MontarMascara(string cpf)
{
string aux = "";

// Retirar todos os caracteres que não sejam numéricos
for (int i = 0; i < cpf.Length; i++)
{
if (char.IsNumber(cpf[i]))
aux += cpf[i].ToString();
}

if (aux.Length != 11)
return cpf;

string pmontado = "";
pmontado = aux.Substring(0, 3) + ".";
pmontado += aux.Substring(3, 3) + ".";
pmontado += aux.Substring(6, 3) + "-";
pmontado += aux.Substring(9, 2);

return pmontado;
}

}

segunda-feira, 8 de janeiro de 2007

Como tocar os sons padrões do Windows?

Algumas vezes, você precisa fazer sua aplicação se tornar mais audível. Se você está usando o .NET 2.0, pode utilizar o novo namespace System.Media e suas classes, SystemSound e SystemSounds.

A classe SystemSounds contém cinco propriedades estáticas (static) que você pode usar para recuperar instâncias da classe SystemSound. Esta classe contém o método Play(), com o qual você pode tocar arquivos "wave" associados com o som no Painel de Controle do Windows. Note que o usuário pode desabilitar todos os sons completamente, o que significaria que o operador do sistema não ouviria nenhum som.

Para tocar o clássico Beep, você poderia usar o seguinte código:

System.Media.SystemSounds.Beep.Play();


Da mesma forma, você pode tocar o som "Question" com o seguinte código:
System.Media.SystemSounds.Question.Play();


O namespace System.Media é definido na System.dll, assim não há nenhuma nova DLL que você precise adicionar ao seu projeto para utilizar o código acima.

Classe de controle de CNPJ (Inclusive validação)

Esta classe contém a validação do dígito verificador e a montagem certa da string de um CNPJ válido.

Para a validação não é necessário passar a string formatada, o código providenciará a limpeza antes da validação.

using System;

public class CNPJ
{
private string _cnpj;
public CNPJ(string cnpj)
{
_cnpj = cnpj;
}

private static string GeraDigito(string cnpj)
{
int pPeso = 2;
int pSoma = 0;

for (int i = cnpj.Length - 1; i >= 0; i--)
{
pSoma += pPeso * Convert.ToInt32(cnpj[i].ToString());
pPeso++;

if (pPeso == 10)
pPeso = 2;
}

int pNumero = (11 - (pSoma % 11));
if (pNumero > 9)
pNumero = 0;

return pNumero.ToString();
}

public static bool Validar(string cnpj)
{
// Se for vazio
if (String.IsNullOrEmpty(cnpj.Trim()))
return false;

// Retirar todos os caracteres que não sejam numéricos
string aux = string.Empty;

for (int i = 0; i < cnpj.Length; i++)
{
if (char.IsNumber(cnpj[i]))
aux += cnpj[i].ToString();
}

// O tamanho do CNPJ tem que ser 14
if (aux.Length != 14)
return false;

// Guardo os dígitos para compará-lo no final
string pDigito = aux.Substring(12, 2);
aux = aux.Substring(0, 12);

//Calculo do 1º digito
aux += GeraDigito(aux);

//Calculo do 2º digito
aux += GeraDigito(aux);


//Comparo os dígitos calculadoscom os guardados anteriormente

return pDigito == aux.Substring(12, 2);
}

public static string MontarMascara(string cnpj)
{
string aux = "";

// Retirar todos os caracteres que não sejam numéricos
for (int i = 0; i < cnpj.Length; i++)
{
if (char.IsNumber(cnpj[i]))
aux += cnpj[i].ToString();
}

if (aux.Length != 14)
return cnpj;

string pmontado = "";
pmontado = aux.Substring(0, 2) + ".";
pmontado += aux.Substring(2, 3) + ".";
pmontado += aux.Substring(5, 3) + "/";
pmontado += aux.Substring(8, 4) + "-";
pmontado += aux.Substring(12, 2);

return pmontado;
}

public override string ToString()
{
return _cnpj;
}
}

Como calcular um Hash MD5 a partir de uma string

Esta é uma prática comum para armazenar senhas em um banco de dados. MD5 (definido no RFC 1321) é uma algorítimo hash comum, e usá-lo no C# é muito simples.

Aqui encontramos uma implementação de um método que converte uma String para um MD5 Hash, contendo uma string de 32 caracteres haxadecimais.

public string CalculateMD5Hash(string input)
{

// Primeiro passo, calcular o MD5 hash a partir da string
MD5 md5 = System.Security.Cryptography.MD5.Create();

byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(input);
byte[] hash = md5.ComputeHash(inputBytes);

// Segundo passo, converter o array de bytes em uma string haxadecimal
StringBuilder sb = new StringBuilder();
for (int i = 0; i < hash.Length; i++) {
sb.Append(hash[i].ToString("X2"));
}

return sb.ToString();

}

Exemplo da chamada da função:
string hash = CalculateMD5Hash("abcdefghijklmnopqrstuvwxyz");

…a string de retorno se parece com isso:
C3FCD3D76192E4007DFB496CCA67E13B

Para transformar a string hexadecimal em caixa baixa(letras minúsculas), substitua a linha dentro do FOR por esta linha:
sb.Append(hash[i].ToString("x2"));

A diferença é o parâmetro do método ToString.

Enviando email em um servidor autenticado!


bool
necessitaAutenticacao = false;

// Crio o cliente de SMTP passando o host e a porta

SmtpClient
clientSMTP = new SmtpClient("host", 25);

// Caso o servidor exija autenticação

if (necessitaAutenticacao)
{
clientSMTP.Credentials = new NetworkCredential("usuário", "senha");
clientSMTP.EnableSsl = true;
}
else clientSMTP.Credentials = CredentialCache.DefaultNetworkCredentials;

// Crio o remetente
MailAddress from = new MailAddress("email_remetente", "nome_remetente(DisplayName)");

// Crio o destinatário
MailAddress to = new MailAddress("email_destinatário", "nome_destinatário(DisplayName)");

// Crio a mensagem passando o remetente e destinatário
MailMessage message = new MailMessage(from, to);

// Corpo da mensagem
message.Body = "Corpo da mensagem";

// Assunto da mensagem
message.Subject = "Assunto";

try
{
// Faço o envio da mensagem
clientSMTP.Send(message);
}
catch (SmtpException ex)
{
// Caso ocorra alguma exceção, capturo a mensagem
Label1.Text = ex.Message;
}

// Destruindo o objeto
message.Dispose();

Enviando Emails com C# de maneira simples

Enviando Emails com C#

A SmtpClient classe é usada para enviar email para um servidor SMTP para
entrega. As classes mostradas na tabela a seguir são usadas para construir mensagens
de email que podem ser enviadas usando SmtpClient.

Attachment Representa arquivo anexos. Essa classe permite-lhe anexar arquivos, fluxos, ou texto a uma mensagem de email.
MailAddress Representa o endereço de email do remetente e destinatários.
MailMessage Representa uma mensagem de email.

Para criar e enviar uma mensagem de email com o Microsoft SmtpClient, você deve especificar as seguintes informações:

  • O servidor host SMTP que você usar para enviar email. Do Host
    Consulte e Portproperties.
  • Credenciais para autenticação, se exigido pelo servidor SMTP. Consulte a Credentials
    propriedade.
  • O endereço de email do remetente. Do Send Consulte e SendAsync métodos que se um from parâmetro.
    Também consulte a propriedade MailMessage.From.
  • O endereço de email ou endereços de destinatários. Do Send Consulte e SendAsync métodos que se um recipient parâmetro. Também consulte a MailMessage.To
    propriedade.
  • O conteúdo da mensagem. Do Send Consulte e SendAsync métodos que se
    um body parâmetro. Também consulte a propriedade MailMessage.Body.


Para incluir um anexo com uma mensagem de email primeiro criar o anexo usando a Attachment classe, e depois adicioná-la para a mensagem usando a MailMessage.Attachments
propriedade. Dependendo do leitor de email usado pelos destinatários e o tipo de arquivo de anexo, alguns destinatários não possam ler o anexo. Para clientes que não podem exibir o anexo no seu formato original, você pode especificar exibições alternativas, utilizando a MailMessage.AlternateViews propriedade.

Você pode usar o aplicativo ou computador arquivos de configuração para especificar host padrão, porta, e valores credenciais para todos os SmtpClient objetos Para obter mais informações, consulte mailSettings elemento (configurações de rede).

Para enviar a mensagem de email e bloco enquanto aguarda o email para serem transmitidos
para o servidor SMTP, utilize um dos métodos síncronos Send. Para permitir segmento principal do seu programa para continuar executando enquanto o email é transmitido, use um dos métodos assíncronos SendAsync. O SendCompleted evento será gerado quando conclui uma SendAsync operação. Para receber nesse caso, você deve adicionar um SendCompletedEventHandler representante para SendCompleted. O SendCompletedEventHandler representante deve fazer referência um método de retorno de chamada que trata notificação de SendCompleted eventos. Para cancelar uma transmissão de email assíncrona, use o SendAsyncCancel método.

SMTP está definido no RFC 2821, que está disponível em http://www.ietf.org/.
O exemplo de código a seguir demonstra enviar uma mensagem de email de forma assíncrona.




using System;
using System.Net;
using System.Net.Mail;
using System.Net.Mime;
using System.Threading;
using System.ComponentModel;
namespace Examples.SmptExamples.Async
{
public class SimpleAsynchronousExample
{
static bool mailSent = false;
public static void SendCompletedCallback(object sender, AsyncCompletedEventArgs e)
{
// Get the unique identifier for this asynchronous operation.
String token = (string) e.UserState;

if (e.Cancelled)
{
Console.WriteLine("[{0}] Send canceled.", token);
}
if (e.Error != null)
{
Console.WriteLine("[{0}] {1}", token, e.Error.ToString());
} else
{
Console.WriteLine("Message sent.");
}
mailSent = true;
}
public static void Main(string[] args)
{
// Command line argument must the the SMTP host.
SmtpClient client = new SmtpClient(args[0]);
// Specify the e-mail sender.
// Create a mailing address that includes a UTF8 character
// in the display name.
MailAddress from = new MailAddress("jane@contoso.com",
"Jane " + (char)0xD8+ " Clayton",
System.Text.Encoding.UTF8);
// Set destinations for the e-mail message.
MailAddress to = new MailAddress("ben@contoso.com");
// Specify the message content.
MailMessage message = new MailMessage(from, to);
message.Body = "This is a test e-mail message sent by an application. ";
// Include some non-ASCII characters in body and subject.
string someArrows = new string(new char[] {'\u2190', '\u2191', '\u2192', '\u2193'});
message.Body += Environment.NewLine + someArrows;
message.BodyEncoding = System.Text.Encoding.UTF8;
message.Subject = "test message 1" + someArrows;
message.SubjectEncoding = System.Text.Encoding.UTF8;
// Set the method that is called back when the send operation
ends.

client.SendCompleted += new
SendCompletedEventHandler(SendCompletedCallback);
// The userState can be any object that allows your callback

// method to identify this send operation.
// For this example, the userToken is a string constant.
string userState = "test message1";
client.SendAsync(message, userState);
Console.WriteLine("Sending message... press c to cancel mail. Press any other key to exit.");
string answer = Console.ReadLine();
// If the user canceled the send, and mail hasn't been sent
yet,

// then cancel the pending operation.
if (answer.StartsWith("c") && mailSent == false)
{
client.SendAsyncCancel();
}
// Clean up.
message.Dispose();
Console.WriteLine("Goodbye.");
}
}
}

Neobux