public void SendEmail(EmailMessage message, string account)
        {
            var fromAddress = new MailAddress(message.From);
            var toAddress = new MailAddress(message.To);

            var mailMessage = new MailMessage(fromAddress, toAddress);            
            mailMessage.Subject = message.Subject;

            if (message.Bcc != null)
            {
                mailMessage.Bcc.Add(new MailAddress(message.Bcc));
            }

            mailMessage.Body = message.Message;
            mailMessage.IsBodyHtml = message.IsHtml;

            var networkCredentials = _credentials.GetCredentialsForAccount(account);
            if (networkCredentials == null)
            {
                throw new Exception(String.Format(
                    "No credentials has been set for account: {0}. Please set up corresponding record in database", account
                    ));
            }

            var client = new SmtpClient();
            client.DeliveryMethod = SmtpDeliveryMethod.Network;
            client.Credentials = networkCredentials;
            client.Host = "mail.trackyt.net";
            client.Port = 587;
            client.EnableSsl = false;
            client.Send(mailMessage);
        }

 private static async Task SendEmail()
 {
     var emailMessage = new EmailMessage();
     emailMessage.To.Add(new EmailRecipient("[email protected]"));
     emailMessage.Subject = "Toastmaster Tools Feedback";
     await EmailManager.ShowComposeNewEmailAsync(emailMessage);
 }

        public bool SendEmail(EmailMessage message, bool sendTranslated = false)
        {
            if (message.IsSent)
                return false;

            MailMessage eMessage = new MailMessage();
            eMessage.To.Add(message.To);
            eMessage.From = new MailAddress(message.From);
            eMessage.Subject = message.Subject;

            if (sendTranslated)
                eMessage.Body = message.TranslatedBody;
            else
                eMessage.Body = message.Body;

            eMessage.IsBodyHtml = true;

            try
            {
                _smtpClient.Send(eMessage);
                message.IsSent = true;
                return true;
            }
            catch (Exception ex)
            {
                message.IsSent = false;
                return false;
            }
        }

        public void StartWork()
        {
            if (emailEntry.State == WorkState.Success)
            {
                OnWorkCompleted(WorkState.Success);
                return;
            }

            if (!emailEntry.IsValid)
            {
                OnWorkCompleted(emailEntry.State);
                return;
            }

            emailEntry.State = WorkState.InProgress;

            var message = new EmailMessage(emailEntry.RecipientAddress, emailEntry.EmailSubject, emailEntry.EmailContent, settingsRepository.GetSettings().SenderEmailAddress);
            messageId = message.MessageId;

            apiExtension.SendMessageAsync(message, result =>
                {
                    switch (result.RoutingState)
                    {
                        case RoutingState.DestinationAccepted:
                            if (emailEntry.State == WorkState.InProgress)
                                emailEntry.State = WorkState.Routed;
                            break;
                        case RoutingState.DestinationNotFound:
                            OnWorkCompleted(WorkState.DeliveringFailed);
                            apiExtension.MessageSubmitted -= apiExtension_MessageSubmitted;
                            break;
                    }
                });
        }

        public void ComposeEmail(IEnumerable<string> to, IEnumerable<string> cc = null, string subject = null, string body = null, bool isHtml = false,
            IEnumerable<EmailAttachment> attachments = null, string dialogTitle = null)
        {
            var message = new EmailMessage
            {
                Subject = subject,
                Body = body
            };

            foreach (var recipient in to)
            {
                message.To.Add(new EmailRecipient(recipient));
            }

            if (cc != null)
            {
                foreach (var recipient in cc)
                {
                    message.CC.Add(new EmailRecipient(recipient));
                }
            }

            if (attachments != null)
            {
                foreach (var attachment in attachments)
                {
                    var stream = Windows.Storage.Streams.RandomAccessStreamReference.CreateFromStream(attachment.Content.AsRandomAccessStream());
                    message.Attachments.Add(new Windows.ApplicationModel.Email.EmailAttachment(attachment.FileName, stream));
                }
            }

            EmailManager.ShowComposeNewEmailAsync(message);

        }

        public static void SendThread()
        {
            //create SMTP object
            SMTP objSMTP = new SMTP();
            objSMTP.SMTPServers.Add("smtp.socketlabs.com", 25, 60, SMTPAuthMode.AuthLogin, "your_smtp_user", "your_smtp_password");

            /*
             * this sample just sends one message per thread/connection but in the real world you should send about
             * 50-100 messages per connection. You will have to add your database retrieval and loop management here
             *
             * i.e. grab 50 records from db, connect, loop through and send all 50 and then disconnect
             * repeat as long as there are more records to process in database
            */

            //establish connection and keep it open for all messages we send
            objSMTP.Connect();

            EmailMessage objMessage = new EmailMessage();
            objMessage.From = new Address("[email protected]", "Sender Name");
            objMessage.Recipients.Add("[email protected]", "Recipient Name", RecipientType.To);
            objMessage.Subject = "Subject...";
            objMessage.BodyParts.Add("Hi ##FIRSTNAME##, Thank you for your interest in ##PRODUCT##.", BodyPartFormat.Plain, BodyPartEncoding.QuotedPrintable);
            Dictionary<string, string> tokens = new Dictionary<string, string>();
            tokens["##FIRSTNAME##"] = "John";
            tokens["##PRODUCT##"] = "SocketLabs Email On-Demand";
            objMessage.BodyParts[0].Body = BulkReplace(objMessage.BodyParts[0].Body, tokens);

            objSMTP.Send(objMessage);

            //close connection after all messages have been sent
            objSMTP.Disconnect();

            Interlocked.Decrement(ref threadsOpen);
        }

        private async void Developer_Click(object sender, RoutedEventArgs e)
        {
            EmailMessage emailMessage = new EmailMessage();
            emailMessage.To.Add(new EmailRecipient("[email protected]"));
            await EmailManager.ShowComposeNewEmailAsync(emailMessage);

        }

        static void Main() {
            Console.WriteLine("Start of publisher");

            Bus.Initialize(cfg => {
                cfg.ReceiveFrom("msmq://localhost/mytestqueue");
                cfg.UseMsmq(mq => mq.UseMulticastSubscriptionClient());
                cfg.VerifyMsDtcConfiguration();
            });
            
            IServiceBus bus = Bus.Instance;
            for (;;) {
                Console.Write("Messsage: ");
                string text = Console.ReadLine();
                if (string.IsNullOrEmpty(text))
                    break;
                char command = text.ToLower()[0];
                string name = text.Substring(1);

                switch (command) {
                    case 'e':
                        var emailMessage = new EmailMessage { Name = name, EmailAddress = "[email protected]" };
                        bus.Publish(emailMessage);
                        break;
                    case 'p':
                        var phoneMessage = new PhoneMessage {Name = name, Received = DateTime.Now, PhoneNumber = "(212) 555-1212"};
                        bus.Publish(phoneMessage);
                        break;
                    default:
                        Console.WriteLine("Preceed message with e for email or p for phone call.");
                        break;
                }
            }
        }

 ///<summary>Inserts one EmailMessage into the database.  Returns the new priKey.</summary>
 internal static long Insert(EmailMessage emailMessage)
 {
     if(DataConnection.DBtype==DatabaseType.Oracle) {
         emailMessage.EmailMessageNum=DbHelper.GetNextOracleKey("emailmessage","EmailMessageNum");
         int loopcount=0;
         while(loopcount<100){
             try {
                 return Insert(emailMessage,true);
             }
             catch(Oracle.DataAccess.Client.OracleException ex){
                 if(ex.Number==1 && ex.Message.ToLower().Contains("unique constraint") && ex.Message.ToLower().Contains("violated")){
                     emailMessage.EmailMessageNum++;
                     loopcount++;
                 }
                 else{
                     throw ex;
                 }
             }
         }
         throw new ApplicationException("Insert failed.  Could not generate primary key.");
     }
     else {
         return Insert(emailMessage,false);
     }
 }

        public static async void OpenEmailClientWithoutPayload()
        {
            IDeviceInfoService _deviceInfoService = ((App)App.Current).Scope.Resolve<IDeviceInfoService>();

            EmailMessage emailMessage = new EmailMessage();

            var credentialsProvider = ((App)Application.Current).Scope.Resolve<ICredentialsProvider>();
            var creds = credentialsProvider.ProvideCredentials(CancellationToken.None);

            var catalogProvider = ((App)Application.Current).Scope.Resolve<ICatalogProvider>();
            var books = await catalogProvider.GetMyBooksFromCache(CancellationToken.None);

            var bookProvider = ((App)Application.Current).Scope.Resolve<IBookProvider>();
            var exists = await bookProvider.GetExistBooks(CancellationToken.None);

            var stringBuilder = new StringBuilder();

            emailMessage.To.Add(new EmailRecipient("[email protected]"));
            emailMessage.Body = stringBuilder.ToString();
            try
            {
                await EmailManager.ShowComposeNewEmailAsync(emailMessage);
            }
            catch (Exception e)
            {
                return;
            }
        }

        public ActionResult Contact(ContactForm contactForm)
        {
            JsonNetResult jsonNetResult = new JsonNetResult();
            jsonNetResult.Formatting = Formatting.Indented;
            try
            {
                string subject = "Online Contact From " + contactForm.Name;
                string message = contactForm.Message;
                message += "\r\n\r\n  " + contactForm.Name;
                message += "\r\n   " + contactForm.EmailAddress;
                message += "\r\n   " + contactForm.Number;

                string sendto = Settings.Default.ContactEmail;

                EmailMessage Message = new EmailMessage()
                {
                    Message = message,
                    Subject = subject,
                    EmailAddressFrom = contactForm.EmailAddress,
                    ContactName = contactForm.Name,
                    EmailAddressTo = sendto
                };
                Message.SendMessage();
                Message = null;

                jsonNetResult.Data = new { Result = "success" };
            }
            catch (Exception ex)
            {
                jsonNetResult.Data = new { Result = "fail", Message = ex.Message };
            }
            return jsonNetResult;
        }

        /// <summary>
        ///     Creates a MailMessage for the current MailAttribute instance.
        /// </summary>
        protected EmailMessage GenerateProspectiveMailMessage(MailAttributes mail)
        {
            //create base message
            var message = new EmailMessage
            {
                FromName = mail.From.DisplayName,
                FromEmail = mail.From.Address,
                To = mail.To.Union(mail.Cc).Select(t => new EmailAddress(t.Address, t.DisplayName)),
                BccAddress = mail.Bcc.Any() ? mail.Bcc.First().Address : null,
                Subject = mail.Subject,
                Important = mail.Priority == MailPriority.High ? true : false
            };

            // We need to set Reply-To as a custom header
            if (mail.ReplyTo.Any())
            {
                message.AddHeader("Reply-To", string.Join(" , ", mail.ReplyTo));
            }

            // Adding content to the message
            foreach (var view in mail.AlternateViews)
            {
                var reader = new StreamReader(view.ContentStream, Encoding.UTF8, true, 1024, true);

                var body = reader.ReadToEnd();

                if (view.ContentType.MediaType == MediaTypeNames.Text.Plain)
                {
                    message.Text = body;
                }
                if (view.ContentType.MediaType == MediaTypeNames.Text.Html)
                {
                    message.Html = body;
                }
            }

            // Going through headers and adding them to the message
            mail.Headers.ToList().ForEach(h => message.AddHeader(h.Key, h.Value));

            // Adding the attachments
            var attachments = new List<EmailAttachment>();
            foreach (var mailAttachment in mail.Attachments.Select(attachment => ActionMailerNext.Utils.AttachmentCollection.ModifyAttachmentProperties(attachment.Key, attachment.Value, false)))
            {
                using (var stream = new MemoryStream())
                {
                    mailAttachment.ContentStream.CopyTo(stream);
                    var base64Data = Convert.ToBase64String(stream.ToArray());
                    attachments.Add(new EmailAttachment
                    {
                        Content = base64Data,
                        Name = mailAttachment.Name,
                        Type = mailAttachment.ContentType.MediaType,
                    });
                }
            }

            message.Attachments = attachments;

            return message;
        }

 private async void ComposeEmail()
 {
     var email = new EmailMessage();
     var recipient = new EmailRecipient("[email protected]", "Janerson Douglas");
     email.To.Add(recipient);
     await EmailManager.ShowComposeNewEmailAsync(email);
 }

 private async void hlbFeedback_Click(object sender, RoutedEventArgs e)
 {
     EmailMessage emailMessage = new EmailMessage();
     emailMessage.Subject = "Elementary Notes - Feedback";
     emailMessage.To.Add(new EmailRecipient("[email protected]"));
     await EmailManager.ShowComposeNewEmailAsync(emailMessage);
 }

        public static MailMessage BuildMessageAndViews(EmailMessage message, out AlternateView textView, out AlternateView htmlView)
        {
            var smtpMessage = new MailMessage { BodyEncoding = Encoding.UTF8, From = new MailAddress(message.From) };
            if(message.To.Count > 0) smtpMessage.To.Add(string.Join(",", message.To));
            if(message.ReplyTo.Count > 0) smtpMessage.ReplyToList.Add(string.Join(",", message.ReplyTo));
            if(message.Cc.Count > 0) smtpMessage.CC.Add(string.Join(",", message.Cc));
            if(message.Bcc.Count > 0) smtpMessage.Bcc.Add(string.Join(",", message.Bcc));
            
            htmlView = null;
            textView = null;

            if (!string.IsNullOrWhiteSpace(message.HtmlBody))
            {
                var mimeType = new ContentType("text/html");
                htmlView = AlternateView.CreateAlternateViewFromString(message.HtmlBody, mimeType);
                smtpMessage.AlternateViews.Add(htmlView);
            }

            if (!string.IsNullOrWhiteSpace(message.TextBody))
            {
                const string mediaType = "text/plain";
                textView = AlternateView.CreateAlternateViewFromString(message.TextBody, smtpMessage.BodyEncoding, mediaType);
                textView.TransferEncoding = TransferEncoding.SevenBit;
                smtpMessage.AlternateViews.Add(textView);
            }
            return smtpMessage;
        }

        protected async void Button1_Click(object sender, EventArgs e)
        {




                MandrillApi api = new MandrillApi("Mandrill Api Key", true);

                IEnumerable<EmailAddress> addresses = new[]
            {
                new EmailAddress("[email protected]", "Name Of the Contact"),
                
            };




                var message = new EmailMessage();

                message.FromEmail = "[email protected]";
                message.FromName = "Your name";
            message.Html = "emailbody";
                message.Text = "emailbodytext";
            message.Subject = "subject";
                message.To = addresses;
              

                SendMessageRequest req = new SendMessageRequest(message);

                var returnvalue = await api.SendMessage(req);
             
            }

        private async void App_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            e.Handled = true;
            var unhandledException = e.Exception;

            var dialog = new MessageDialog([email protected]"Homebased crashed :(
                {Environment.NewLine}Please close the application and try again.
                {Environment.NewLine}But before you do, do you want to mail us the crash report, to see if there's anything we can do?", "Homebased crashed #!$*");
            dialog.Commands.Add(new UICommand("Yes", new UICommandInvokedHandler(async cmd => 
            {
                var sendTo = new EmailRecipient()
                {
                    Name = "Homebased",
                    Address = "[email protected]"
                };

                var mail = new EmailMessage();
                mail.Subject = $"Homebased crashed :(";
                mail.Body = unhandledException.ToString();

                mail.To.Add(sendTo);

                await EmailManager.ShowComposeNewEmailAsync(mail);
            })));

            dialog.Commands.Add(new UICommand("No", new UICommandInvokedHandler(cmd =>
            {
            })));

            await dialog.ShowAsync();
        }

 public bool Send(EmailMessage message)
 {
     AlternateView textView;
     AlternateView htmlView;
     var smtpMessage = BuildMessageAndViews(message, out textView, out htmlView);
     try
     {
         _client().Send(smtpMessage);
         return true;
     }
     catch (SmtpException)
     {
         return false;
     }
     finally
     {
         if(htmlView != null)
         {
             htmlView.Dispose();
         }
         if(textView != null)
         {
             textView.Dispose();
         }
     }
 }

        public EmailStatus Send(EmailMessage email)
        {
            EmailStatus status = email.Status;
            try
            {
                string emailSender = System.Configuration.ConfigurationManager.AppSettings.Get("email");
                string emailpassword = System.Configuration.ConfigurationManager.AppSettings.Get("emailpassword");
                string notification =System.Configuration.ConfigurationManager.AppSettings.Get("notification");
                string smtp = System.Configuration.ConfigurationManager.AppSettings.Get("smtp");
                int port = int.Parse(System.Configuration.ConfigurationManager.AppSettings.Get("port"));
                bool enableSSL = bool.Parse(System.Configuration.ConfigurationManager.AppSettings.Get("enableSSL"));

                System.Net.Mail.MailMessage msg = new System.Net.Mail.MailMessage();
                msg.From = new MailAddress(emailSender);
                msg.Subject = email.Subject;
                msg.To.Add(email.Recipient.Email);

                //confimacao de leitura
                msg.Headers.Add("Disposition-Notification-To", emailSender);

                msg.DeliveryNotificationOptions = DeliveryNotificationOptions.OnFailure |
                                                  DeliveryNotificationOptions.OnSuccess |
                                                  DeliveryNotificationOptions.Delay;

                foreach (var item in email.CC)
                    msg.CC.Add(item.Email);

                foreach (var item in email.CCO)
                    msg.Bcc.Add(item.Email);

                msg.Body = email.ContentMessage;
                msg.IsBodyHtml = email.IsHtmlMessage;

                SmtpClient emailClient = new SmtpClient(smtp);
                System.Net.NetworkCredential SMTPUserInfo = new System.Net.NetworkCredential(emailSender, emailpassword);
                emailClient.UseDefaultCredentials = false;

                emailClient.Credentials = SMTPUserInfo;
                emailClient.Port = port;
                emailClient.EnableSsl = enableSSL;

                foreach (var item in email.Attachments)
                {
                    Attachment attach = new Attachment(new MemoryStream(item.File), item.Name);
                    msg.Attachments.Add(attach);
                }

                emailClient.Send(msg);

                status = EmailStatus.Sent;
            }
            catch (Exception ex)
            {
                email.SetStatusMessage(ex.Message);
                status = EmailStatus.Fail;
            }

            return status;
        }

        private async void FeedbackButton_OnClick(object sender, RoutedEventArgs e)
        {
            var em = new EmailMessage();
            em.To.Add(new EmailRecipient("[email protected]", "Jason Young"));
            em.Subject = "Keep Moving Feedback";

            await EmailManager.ShowComposeNewEmailAsync(em);
        }