C#邮件发送与附件处理过程详解

发件人 → smtp服务器 → 收件人邮件服务器 → 收件人

1. 发件人信息：邮箱地址、显示名称​
2. 收件人信息：邮箱地址（可以多个）​
3. 邮件内容：主题、正文​
4. 附件：可选的文件附加​
5. smtp 服务器配置：服务器地址、端口、认证信息

**smtp (simple mail transfer protocol)** 是简单邮件传输协议，是用于发送电子邮件的标准协议。

using system.net;
using system.net.mail;
using system.net.mime;

mailmessage mail = new mailmessage();
mail.from = new mailaddress("sender@example.com", "发件人显示名称");
mail.to.add("recipient@example.com");
mail.subject = "邮件主题";
mail.body = "邮件正文内容";
mail.isbodyhtml = true; // 是否支持html格式

smtpclient smtpclient = new smtpclient("smtp.server.com", 587);
smtpclient.credentials = new networkcredential("username", "password");
smtpclient.enablessl = true;
smtpclient.send(mail);

attachment attachment = new attachment("file.txt");
mail.attachments.add(attachment);

using system;
using system.net;
using system.net.mail;

class simpleemailsender
{
    static void main(string[] args)
    {
        try
        {
            // 1. 创建邮件消息
            mailmessage mail = new mailmessage();
            mail.from = new mailaddress("your-email@example.com", "你的名称");
            mail.to.add("recipient@example.com");
            mail.subject = "测试邮件";
            mail.body = "这是一封测试邮件！";
            mail.isbodyhtml = false;

            // 2. 配置smtp客户端
            smtpclient smtpclient = new smtpclient("smtp.server.com", 587);
            smtpclient.credentials = new networkcredential("your-email@example.com", "your-password");
            smtpclient.enablessl = true;

            // 3. 发送邮件
            smtpclient.send(mail);
            console.writeline("邮件发送成功！");
        }
        catch (exception ex)
        {
            console.writeline($"邮件发送失败: {ex.message}");
        }
    }
}

using system;
using system.collections.generic;
using system.io;
using system.linq;
using system.net;
using system.net.mail;
using system.net.mime;
using system.text;

namespace tools.mail
{
    /// <summary>
    /// smtp邮件发送器，支持发送带附件的邮件
    /// </summary>
    public static class smtpemailhelper
    {
        #region 配置参数
        // smtp服务器配置
        private const string smtpserver = "  ";
        private const int smtpport = 80;
        private const bool enablessl = false;
        
        // 发件人信息
        private const string fromaddress = "system@example.com";
        private const string fromdisplayname = "系统通知";
        private const string smtpusername = "system@example.com";
        private const string smtppassword = "your-password";
        
        // 附件配置
        private const int maxattachmentsize = 8 * 1024 * 1024; // 单个附件最大8mb
        private const int maxtotalattachmentsize = 12 * 1024 * 1024; // 总附件大小限制
        #endregion

        #region 附件数据结构
        /// <summary>
        /// 邮件附件信息
        /// </summary>
        public class emailattachment
        {
            /// <summary>
            /// 文件名
            /// </summary>
            public string filename { get; set; }
            
            /// <summary>
            /// 文件内容（字节数组）
            /// </summary>
            public byte[] content { get; set; }
            
            /// <summary>
            /// 内容类型
            /// </summary>
            public string contenttype { get; set; }
        }
        #endregion

        #region 发送邮件方法
        /// <summary>
        /// 发送带附件的邮件
        /// </summary>
        /// <param name="toaddress">收件人地址（多个用逗号分隔）</param>
        /// <param name="subject">邮件主题</param>
        /// <param name="htmlbody">html邮件正文</param>
        /// <param name="attachments">附件列表</param>
        public static void sendemailwithattachments(string toaddress, string subject,
                                                  string htmlbody, list<emailattachment> attachments = null)
        {
            try
            {
                // 创建邮件消息
                mailmessage mail = createmailmessage(toaddress, subject, htmlbody);
                
                // 添加附件
                if (attachments != null && attachments.any())
                {
                    addattachmentstomail(mail, attachments);
                }
                
                // 发送邮件
                sendmail(mail);
            }
            catch (exception ex)
            {
                console.writeline($"邮件发送失败: {ex.message}");
                throw;
            }
        }
        #endregion

        #region 邮件创建
        private static mailmessage createmailmessage(string toaddress, string subject, string htmlbody)
        {
            mailmessage mail = new mailmessage();
            
            // 发件人
            mail.from = new mailaddress(fromaddress, fromdisplayname, encoding.utf8);
            
            // 收件人
            foreach (string receiver in toaddress.split(new[] { ',' }, stringsplitoptions.removeemptyentries))
            {
                mail.to.add(new mailaddress(receiver.trim()));
            }
            
            // 邮件主题
            mail.subject = subject;
            mail.subjectencoding = encoding.utf8;
            
            // 邮件正文（html格式）
            mail.body = htmlbody;
            mail.bodyencoding = encoding.utf8;
            mail.isbodyhtml = true;
            
            // 优先级
            mail.priority = mailpriority.high;
            
            return mail;
        }
        #endregion

        #region 附件处理
        private static void addattachmentstomail(mailmessage mail, list<emailattachment> attachments)
        {
            long totalattachmentsize = 0;
            
            foreach (var attachment in attachments)
            {
                if (attachment == null || attachment.content == null || attachment.content.length == 0)
                    continue;
                
                // 检查单个附件大小
                if (attachment.content.length > maxattachmentsize)
                {
                    console.writeline($"附件 {attachment.filename} 太大，跳过添加");
                    continue;
                }
                
                // 检查总附件大小
                if (totalattachmentsize + attachment.content.length > maxtotalattachmentsize)
                {
                    console.writeline($"总附件大小超出限制，跳过添加附件 {attachment.filename}");
                    break;
                }
                
                try
                {
                    // 创建附件
                    attachment mailattachment = new attachment(
                        new memorystream(attachment.content),
                        attachment.filename,
                        attachment.contenttype ?? "application/octet-stream"
                    );
                    
                    // 设置附件属性
                    contentdisposition disposition = mailattachment.contentdisposition;
                    disposition.creationdate = datetime.now;
                    disposition.modificationdate = datetime.now;
                    disposition.readdate = datetime.now;
                    disposition.filename = attachment.filename;
                    disposition.size = attachment.content.length;
                    disposition.dispositiontype = dispositiontypenames.attachment;
                    
                    mail.attachments.add(mailattachment);
                    totalattachmentsize += attachment.content.length;
                    
                    console.writeline($"添加附件成功: {attachment.filename}");
                }
                catch (exception ex)
                {
                    console.writeline($"添加附件 {attachment.filename} 失败: {ex.message}");
                }
            }
        }
        #endregion

        #region 邮件发送
        private static void sendmail(mailmessage mail)
        {
            using (smtpclient smtpclient = new smtpclient(smtpserver, smtpport))
            {
                smtpclient.enablessl = enablessl;
                smtpclient.credentials = new networkcredential(smtpusername, smtppassword);
                smtpclient.timeout = 300000; // 5分钟超时
                smtpclient.deliverymethod = smtpdeliverymethod.network;
                
                // 发送邮件
                smtpclient.send(mail);
            }
            
            console.writeline($"邮件发送成功，收件人: {string.join(",", mail.to.select(t => t.address))}");
        }
        #endregion
    }
}

/// <summary>
/// 批次报告数据模型
/// 包含所有生成报告所需的业务数据
/// </summary>
public class batchreportdata
{
    public int batch { get; set; }                  // 批次号
    public int year { get; set; }                   // 年份
    public int totalcount { get; set; }             // 总企业数
    public int successcount { get; set; }           // 成功处理数
    public int errorcount { get; set; }             // 错误数
    public int unobtainedcount { get; set; }        // 未获取数
    public list<batchrecordmodel> abnormalrecords { get; set; }  // 异常记录
    public list<batchrecordmodel> unobtainedrecords { get; set; } // 未获取记录
    public list<string> errorlogs { get; set; }     // 错误日志
    public string receivers { get; set; }           // 收件人列表
    public datetime generatetime { get; set; }      // 生成时间
}

/// <summary>
/// 准备批次报告所需的业务数据
/// </summary>
private batchreportdata preparebatchreportdata(int batch, list<string> errors)
{
    // 1. 获取当前年份
    int year = datetime.now.year;
    
    // 2. 查询批次记录
    list<batchrecordmodel> batchrecords = _enterpriseprovider.getbatchrecords(batch, year);
    
    if (!batchrecords.any())
    {
        logger.warn($"批次{batch}年度{year}没有找到记录");
        return null;
    }
    
    // 3. 统计数据
    int totalcount = batchrecords.count;
    int successcount = batchrecords.count(r => r.status == 1);
    int errorcount = batchrecords.count(r => r.status == 2);
    int unobtainedcount = batchrecords.count(r => r.status == 0);
    
    // 4. 获取异常和未获取记录
    list<batchrecordmodel> abnormalrecords = batchrecords.where(r => r.hasabnormaldata == 1).tolist();
    list<batchrecordmodel> unobtainedrecords = batchrecords.where(r => r.status == 0).tolist();
    
    // 5. 获取收件人配置
    string receivers = _configprovider.getemailreceivers();
    
    return new batchreportdata
    {
        batch = batch,
        year = year,
        totalcount = totalcount,
        successcount = successcount,
        errorcount = errorcount,
        unobtainedcount = unobtainedcount,
        abnormalrecords = abnormalrecords,
        unobtainedrecords = unobtainedrecords,
        errorlogs = errors ?? new list<string>(),
        receivers = receivers,
        generatetime = datetime.now
    };
}

/// <summary>
/// 生成html格式的邮件正文
/// </summary>
private string generateemailhtmlbody(batchreportdata reportdata)
{
    stringbuilder htmlbuilder = new stringbuilder();
    
    htmlbuilder.appendline("<!doctype html>");
    htmlbuilder.appendline("<html lang='zh-cn'>");
    htmlbuilder.appendline("<head>");
    htmlbuilder.appendline("<meta charset='utf-8'>");
    htmlbuilder.appendline("<title>批次处理结果报告</title>");
    htmlbuilder.appendline("<style>");
    htmlbuilder.appendline("body { font-family: 'microsoft yahei', arial, sans-serif; line-height: 1.6; }");
    htmlbuilder.appendline(".container { max-width: 800px; margin: 0 auto; padding: 20px; }");
    htmlbuilder.appendline(".header { background-color: #f5f5f5; padding: 15px; text-align: center; border-radius: 5px; }");
    htmlbuilder.appendline(".content { margin: 20px 0; }");
    htmlbuilder.appendline(".stats { background-color: #f9f9f9; padding: 15px; border-radius: 5px; margin: 15px 0; }");
    htmlbuilder.appendline(".stat-item { margin: 8px 0; }");
    htmlbuilder.appendline(".footer { text-align: center; margin-top: 30px; color: #666; font-size: 14px; }");
    htmlbuilder.appendline("</style>");
    htmlbuilder.appendline("</head>");
    htmlbuilder.appendline("<body>");
    htmlbuilder.appendline("<div class='container'>");
    
    // 邮件头部
    htmlbuilder.appendline("<div class='header'>");
    htmlbuilder.appendline($"<h2>批次处理结果报告 - 批次{reportdata.batch} ({reportdata.year}年度)</h2>");
    htmlbuilder.appendline("</div>");
    
    // 处理时间
    htmlbuilder.appendline("<div class='content'>");
    htmlbuilder.appendline($"<p>报告生成时间：{reportdata.generatetime.tostring("yyyy-mm-dd hh:mm:ss")}</p>");
    
    // 统计信息
    htmlbuilder.appendline("<div class='stats'>");
    htmlbuilder.appendline("<h3>处理统计</h3>");
    htmlbuilder.appendline($"<div class='stat-item'>总企业数：<strong>{reportdata.totalcount}</strong></div>");
    htmlbuilder.appendline($"<div class='stat-item'>成功处理：<strong>{reportdata.successcount}</strong></div>");
    htmlbuilder.appendline($"<div class='stat-item'>处理失败：<strong>{reportdata.errorcount}</strong></div>");
    htmlbuilder.appendline($"<div class='stat-item'>未获取信息：<strong>{reportdata.unobtainedcount}</strong></div>");
    htmlbuilder.appendline("</div>");
    
    // 异常企业信息
    if (reportdata.abnormalrecords.any())
    {
        htmlbuilder.appendline("<div class='stats'>");
        htmlbuilder.appendline($"<h3>异常企业 ({reportdata.abnormalrecords.count}家)</h3>");
        htmlbuilder.appendline("<p>以下企业存在经营异常或严重违法记录，请及时处理。</p>");
        htmlbuilder.appendline("</div>");
    }
    
    // 邮件底部
    htmlbuilder.appendline("<div class='footer'>");
    htmlbuilder.appendline("<p>此邮件为系统自动发送，请勿回复。详细信息请查看附件。</p>");
    htmlbuilder.appendline("</div>");
    
    htmlbuilder.appendline("</div>");
    htmlbuilder.appendline("</div>");
    htmlbuilder.appendline("</body>");
    htmlbuilder.appendline("</html>");
    
    return htmlbuilder.tostring();
}

/// <summary>
/// 生成报告附件
/// </summary>
private list<smtpemailhelper.emailattachment> generatereportattachments(batchreportdata reportdata)
{
    list<smtpemailhelper.emailattachment> attachments = new list<smtpemailhelper.emailattachment>();
    
    // 生成csv格式的详细报告
    byte[] csvcontent = generatecsvreport(reportdata);
    attachments.add(new smtpemailhelper.emailattachment
    {
        filename = $"批次{reportdata.batch}_处理报告_{reportdata.generatetime:yyyymmddhhmmss}.csv",
        content = csvcontent,
        contenttype = "text/csv"
    });
    
    // 生成错误日志文件
    if (reportdata.errorlogs.any())
    {
        byte[] errorlogcontent = generateerrorlogfile(reportdata);
        attachments.add(new smtpemailhelper.emailattachment
        {
            filename = $"批次{reportdata.batch}_错误日志_{reportdata.generatetime:yyyymmddhhmmss}.txt",
            content = errorlogcontent,
            contenttype = "text/plain"
        });
    }
    
    return attachments;
}

/// <summary>
/// 生成csv格式报告
/// </summary>
private byte[] generatecsvreport(batchreportdata reportdata)
{
    using (memorystream ms = new memorystream())
    using (streamwriter writer = new streamwriter(ms, encoding.utf8))
    {
        // csv头部
        writer.writeline("企业名称,统一社会信用代码,处理状态,异常类型,获取时间,备注");
        
        // 处理数据行
        foreach (var record in reportdata.abnormalrecords)
        {
            string status = record.status == 1 ? "成功" : record.status == 2 ? "失败" : "未处理";
            string abnormaltype = record.hasregstatusabnormal == 1 ? "经营异常" : 
                                 record.hasillegaldata == 1 ? "严重违法" : "其他异常";
            
            writer.writeline($"{csvencode(record.facname)},{csvencode(record.faccode)},{status},{abnormaltype},{record.updatetime:yyyy-mm-dd hh:mm:ss},");
        }
        
        writer.flush();
        return ms.toarray();
    }
}

/// <summary>
/// 生成错误日志文件
/// </summary>
private byte[] generateerrorlogfile(batchreportdata reportdata)
{
    using (memorystream ms = new memorystream())
    using (streamwriter writer = new streamwriter(ms, encoding.utf8))
    {
        writer.writeline($"批次{reportdata.batch}错误日志");
        writer.writeline($"生成时间：{reportdata.generatetime:yyyy-mm-dd hh:mm:ss}");
        writer.writeline($"错误总数：{reportdata.errorlogs.count}");
        writer.writeline();
        writer.writeline("错误详情：");
        writer.writeline();
        
        for (int i = 0; i < reportdata.errorlogs.count; i++)
        {
            writer.writeline($"错误 {i + 1}:");
            writer.writeline(reportdata.errorlogs[i]);
            writer.writeline();
            writer.writeline("-".padright(60, '-'));
            writer.writeline();
        }
        
        writer.flush();
        return ms.toarray();
    }
}

/// <summary>
/// csv编码处理
/// </summary>
private string csvencode(string value)
{
    if (string.isnullorempty(value))
        return string.empty;
    
    // csv编码规则：如果包含逗号、引号或换行符，需要用双引号括起来
    if (value.contains(",") || value.contains("\"") || value.contains("\n") || value.contains("\r"))
    {
        return "\"" + value.replace("\"", "\"\"") + "\"";
    }
    
    return value;
}

/// <summary>
/// 发送批次处理结果邮件报告（带附件版本）
/// 业务逻辑：准备数据 -> 生成内容 -> 调用邮件发送器
/// </summary>
public void sendbatchprocessnotification(int batch, list<string> errors)
{
    try
    {
        // 1. 业务数据准备
        var reportdata = preparebatchreportdata(batch, errors);
        if (reportdata == null)
        {
            logger.warn($"批次{batch}没有数据需要发送");
            return;
        }
        
        // 2. 生成邮件内容（业务逻辑）
        string emailsubject = $"批次{reportdata.batch}处理结果报告 - {reportdata.year}年度";
        string htmlbody = generateemailhtmlbody(reportdata);
        
        // 3. 生成附件（业务逻辑）
        var attachments = generatereportattachments(reportdata);
        
        // 4. 调用独立的邮件发送器（不包含业务逻辑）
        sendemailthroughsmtp(reportdata.receivers, emailsubject, htmlbody, attachments);
        
        logger.info($"批次{batch}带附件处理结果邮件已发送");
    }
    catch (exception ex)
    {
        logger.error($"发送批次{batch}带附件邮件报告失败: {ex.message}", ex);
    }
}

/// <summary>
/// 通过smtp发送邮件（仅负责调用，不包含业务逻辑）
/// </summary>
private void sendemailthroughsmtp(string receivers, string subject, string htmlbody,
                                list<smtpemailhelper.emailattachment> attachments)
{
    try
    {
        // 直接调用独立的邮件发送器
        smtpemailhelper.sendemailwithattachments(receivers, subject, htmlbody, attachments);
    }
    catch (exception ex)
    {
        logger.error($"smtp邮件发送器调用失败: {ex.message}", ex);
        throw;
    }
}