Sim, parece-me que é isto que Dmitry Robsman mostra em seu último post. Não tive a oportunidade de testar, mas parece-me algo bem interessante.

Como já mencionei anteriormente nestes links, a forma e opções de envio mudaram bastante no .NET Framework 2.0. Uma das novas funcionalidades, quais não mencionei nos posts anteriores, é utilizar o arquivo *.config da aplicação para definir algumas propriedades essenciais para o envio de e-mails, tais como: Host (endereço do servidor de SMTP), Porta e Credenciais.

Para possibilitar isso, a Microsoft adicionou novos elementos no arquivo *.config da aplicação, sendo eles: system.net, mailsettings, smtp e network. Claro que, nas versões do .NET 1.x, poderíamos definir uma key no arquivo *.config para não deixarmos estes valores (que mudam constantemente, como o endereço do servidor de SMTP) em hard-code. Esses novos elementos poupam-nos de escrever essas keys no appSettings da aplicação e, conseqüentemente, funções e/ou propriedades para recuperarmos isso. Para exemplificar a nova possibilidade de configuração no .NET Framework 2.0, vejamos o exemplo abaixo:

[ *.config ]
<configuration>
  <system.net>
    <mailSettings>
      <smtp deliveryMethod=”network”>
        <network host=”localhost” port=”25″ defaultCredentials=”true” />
      </smtp>
    </mailSettings>
  </system.net>
</configuration>

[ C# ]
using System.Net.Mail;
//…
MailMessage msg = new MailMessage(“israel @ projetando.net”, “israel @ projetando.net”);
msg.Subject = “Teste”;
msg.Body = “Corpo da Mensagem”;
new SmtpClient().Send(msg);

Pode-se ver que ficou muito mais simplificado, pois quando a aplicação corre, o runtime se encarrega de ir até o arquivo de configuração e recuperar os dados necessários para enviar o email. Mas vale lembrar que, a classe SmtpClient suporta em seu construtor (ou através de suas propriedades), que voce defina estes valores via código.

Agora também faz muito mais sentido ter o namespace Mail dentro do System.Net, pois nas versões anteriores, se estivéssemos em um projeto do tipo Console, ou mesmo Windows Forms, tínhamos que fazer referencia à DLL System.Web.dll se quiséssemos enviar e-mails.

Bem, navegando pelo portal do MSDN.com, encontrei algo que me chamou a atenção na seção do Visual C#. Neste link pude ver que o Visual C# também terá Edit and Continue, uma “feature” bastante interessante que ajuda na depuração dos aplicativos.

Imaginei que esta “feature” fosse somente implementada no Visual Basic .NET (versão 2005), já que o VB6 a tinha, e pelo que pude ver, os desenvolvedores de Visual C# também poderão desfrutar do E & C. 🙂

Finalmente a versão 2.0 do .NET Framework já traz intrinsicamente um recurso que nas versões anteriores somente conseguíamos com a utilização de componentes de terceiros; trata-se da opção de agora podermos embutir dentro do email imagens que farão parte do conteúdo do mesmo.

Nas versões anteriores, se não quiséssemos utilizar componentes de terceiros, tínhamos que disponibilizar em algum lugar, geralmente imagens, que iriam fazer parte do conteúdo do email e, através do acesso via HTTP, a exibíamos. O ponto negativo disso é que depende de uma conexão ativa com a internet para que o usuário consiga visualizar essas imagens.

Felizmente na versão 2.0, temos duas principais classes para trabalharmos com isso. São elas: AlternateView e LinkedResource. A primeira especifica diferentes cópias do conteúdo do email, ou seja, voce define o email com o formato e tags HTML e, se o leitor de emails do destinatário não suportar HTML, voce pode fornecer através desta classe, uma versão em Plain Text do mesmo conteúdo. Já a segunda classe, representa um recurso externo que será embutido dentro do conteúdo do email que, na maioria dos casos, é uma imagem. Depois desta classe criada, o adicionamos na coleção de LinkedResources do objeto AlternateView.

O código abaixo mostra-nos como devemos proceder para conseguirmos enviar um email com uma imagem embutida no corpo do mesmo:

     using System.Net.Mail;
     using System.Net.Mime;

     MailMessage mail = new MailMessage(“israel@projetando.net“, “israel@projetando.net“);
     mail.Subject = “Testando Imagens Embutidas”;
     string body = @”<img src=””cid:Imagem1″” /><br><br>Embutindo Imagens no Email.”;

     AlternateView view = 
          AlternateView.CreateAlternateViewFromString(body, null, MediaTypeNames.Text.Html);

     LinkedResource resource = new LinkedResource(Server.MapPath(“Logo.gif”));
     resource.ContentId = “Imagem1”;
     view.LinkedResources.Add(resource);

     mail.AlternateViews.Add(view);
     mail.IsBodyHtml = true;
     new SmtpClient(“mail.servidor.com.br”).Send(mail);

Como podemos analisar no código acima, criamos uma classe do tipo MailMessage, como já fazíamos nas versões anteriores. Dentro do conteúdo do email (body), definimos a tag img e o atributo src que corresponderá a imagem no local que desejarmos. Através do cdi especificamos que o conteúdo será “substituído” pelo conteúdo que mais tarde vamos vir a embutir. Através do método CreateAlternateViewFromString, onde passamos o corpo da mensagem e o tipo que ela irá ser (no caso HTML), devolvemos uma instancia da classe AlternateView baseada nesses mesmos parametros.

Depois disso, criamos um objeto do tipo LinkedResource, onde vamos definir a imagem (ou recurso) que vamos embutir. É importante dizer que a propriedade ContentId deve ser exatamente o mesmo ID que definimos no cid do corpo da mensagem. Agora basta adicionarmos o objeto na coleção de LinkedResources do objeto AlternateView e, este por sua vez, adicionamos na coleção de Views do objeto MailMessage.

Finalmente, através de uma instancia do objeto SmtpClient, utilizamos o método Send para enviar o email. A Imagem abaixo mostra o email já dentro do Microsoft Outlook. Reparem que a imagem é embutida no local que definimos dentro do código HTML do corpo da mensagem e que também que não existem arquivos anexados ao email.

Via Rockford Lhotka encontrei um link interessante para um site chamado ExceptionCollection.com, qual trata-se de um serviço free para desenvolvedores, onde é fornecido uma espécie de repositório das Exceções que são atiradas e consequentemente apanhadas dentro da nossa aplicação.

Depois de efetuado o cadastro, voce pode se logar neste site e, verificar as Exceções que suas aplicações possivelmente possam ter gerado. Para poder enviar a Exception para o repositório, o código fica semelhante ao mostrado abaixo:

     catch (Exception objException)
     {
          Sherpa.ExceptionReport objExceptionReport;
          objExceptionReport = new Sherpa.ExceptionReport(“login”, objException)

          if(!objExceptionReport.Send())
          {
               // LOG objExceptionReport.ErrorMessageFromFailedSend (OPTIONAL)
          }
     }

Isso tudo é feito/logado através de um WebService ou mesmo fazendo a referencia a uma DLL fornecida pelo próprio site, qual pode ser visto/testado neste link. Para maiores detalhes técnicos do projeto, por favor visite o seguinte endereço: http://www.exceptioncollection.com/instructions.aspx.