阿柒の站

C# 日志记录方案

Thu, 11 Sep 2025 00:00:00 GMT

一个不依赖框架、灵活的日志记录类。

优点:

不依赖其他框架，极简灵活。
分块存储，不怕单文件过大。
写日志时自动检测创建文件，不担心删除文件后写入不了。
随用随调，静态实现，任何地方直接调用就能记录日志。

Logs.cs

public static class Logs
{
    private static readonly ConcurrentQueue<(string Level, string Message, DateTime Time)> LogQueue = new();
    private static readonly CancellationTokenSource TokenSource = new();
    private static readonly string LogRoot = Path.Combine(AppContext.BaseDirectory, "Log"); // 存储路径，默认程序根目录下的Log文件夹下
    private static readonly long MaxFileSize = 5 * 1024 * 1024; // 5MB
    private static DateTime _lastLogTime = DateTime.MinValue;
    private static readonly object WriteLock = new();

    static Logs()
    {
        Task.Factory.StartNew(ProcessQueue, TaskCreationOptions.LongRunning);
    }

    public static void Info(string message) => Enqueue("info", message); // 详情记录
    public static void Error(string message) => Enqueue("error", message); // 错误记录
	// 可继续扩展...

    private static void Enqueue(string level, string message)
    {
        LogQueue.Enqueue((level.ToLower(), message, DateTime.Now));
    }

    private static async Task ProcessQueue()
    {
        while (!TokenSource.IsCancellationRequested)
        {
            while (LogQueue.TryDequeue(out var entry))
            {
                try
                {
                    WriteLog(entry.Level, entry.Message, entry.Time);
                }
                catch
                {
                    // 可扩展重试逻辑或写入到 fallback 文件
                }
            }
            await Task.Delay(100); // 避免空转
        }
    }

    private static void WriteLog(string level, string message, DateTime time)
    {
        var basePath = Path.Combine(LogRoot, time.ToString("yyyy_MM"));
        Directory.CreateDirectory(basePath);

        var filePrefix = Path.Combine(basePath, $"{time:dd}_{level}");
        var filePath = GetAvailableLogFile(filePrefix);

        var content = $"[{time:yyyy-MM-dd HH:mm:ss.fff}] {message}{Environment.NewLine}";

        lock (WriteLock)
        {
            File.AppendAllText(filePath, content, Encoding.UTF8);
        }

        _lastLogTime = time;
    }

    private static string GetAvailableLogFile(string basePath)
    {
        for (int i = 0; i < 1000; i++)
        {
            var filePath = i == 0 ? $"{basePath}.txt" : $"{basePath}_{i}.txt";
            if (!File.Exists(filePath) || new FileInfo(filePath).Length < MaxFileSize)
                return filePath;
        }

        throw new IOException("日志文件已超过最大数量限制");
    }

    public static void Stop()
    {
        TokenSource.Cancel();
    }
}

使用示例：

Logs.Info("记录详情日志");
Logs.Error("记录错误日志");

C# 读写配置文件方案

Thu, 11 Sep 2025 00:00:00 GMT

一个防修改、保持完整性的读写配置文件方案。

ConfigManager.cs

public class ConfigManager
{
    private static readonly string ConfigPath = Path.Combine(AppContext.BaseDirectory, "config.dat"); // 配置文件路径，默认存储在程序根目录
    private static readonly byte[] HmacKey = Encoding.UTF8.GetBytes("abcdefgh"); // 加密密钥

    private Dictionary<string, object> _configData;
    private readonly object _lock = new();

    public static ConfigManager Instance { get; } = new ConfigManager();

    /// <summary>
    /// 构造函数
    /// </summary>
    private ConfigManager()
    {
        Load();
    }

    /// <summary>
    /// 索引器
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public object? this[string key]
    {
        get => Get(key);
        set => Set(key, value);
    }

    /// <summary>
    /// 获取配置项
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public object? Get(string key)
    {
        var sections = key.Split(':', StringSplitOptions.RemoveEmptyEntries);
        object? current = _configData;

        foreach (var section in sections)
        {
            if (current is Dictionary<string, object> dict && dict.TryGetValue(section, out var next))
                current = next;
            else
                return null;
        }

        return current;
    }

    /// <summary>
    /// 设置配置项
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public void Set(string key, object? value)
    {
        var sections = key.Split(':', StringSplitOptions.RemoveEmptyEntries);
        lock (_lock)
        {
            var current = _configData;
            for (int i = 0; i < sections.Length - 1; i++)
            {
                var section = sections[i];
                if (!current.TryGetValue(section, out var sub) || sub is not Dictionary<string, object>)
                {
                    current[section] = new Dictionary<string, object>();
                }
                current = (Dictionary<string, object>)current[section];
            }

            current[sections.Last()] = value!;
        }
    }

    /// <summary>
    /// 存储配置文件
    /// </summary>
    public void Save()
    {
        lock (_lock)
        {
            var json = JsonSerializer.Serialize(_configData);
            var compressed = Compress(Encoding.UTF8.GetBytes(json));
            var signature = HMACSHA256.HashData(HmacKey, compressed);
            var finalData = signature.Concat(compressed).ToArray();
            File.WriteAllBytes(ConfigPath, finalData);
        }
    }

    /// <summary>
    /// 加载配置文件
    /// </summary>
    private void Load()
    {
        try
        {
            if (!File.Exists(ConfigPath))
            {
                // 如果配置文件不存在，可以选择创建一个默认配置
                _configData = [];
                Save();
                //throw new FileNotFoundException();
            }

            var bytes = File.ReadAllBytes(ConfigPath);
            if (bytes.Length < 32)
                throw new Exception("配置文件不完整");

            var signature = bytes.Take(32).ToArray();
            var content = bytes.Skip(32).ToArray();
            var actualSignature = HMACSHA256.HashData(HmacKey, content);

            if (!signature.SequenceEqual(actualSignature))
                throw new Exception("配置文件已被篡改");

            var decompressed = Decompress(content);
            _configData = JsonSerializer.Deserialize<Dictionary<string, object>>(decompressed)!;
        }
        catch
        {
            // 可以在这里加载默认配置

            _configData = [];
            System.Windows.MessageBox.Show("配置文件损坏或不存在，已加载默认配置", "提示", MessageBoxButton.OK, MessageBoxImage.Warning);
        }
    }

    /// <summary>
    /// 压缩配置文件
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    private static byte[] Compress(byte[] data)
    {
        using var output = new MemoryStream();
        using (var gz = new GZipStream(output, CompressionLevel.Optimal))
            gz.Write(data, 0, data.Length);
        return output.ToArray();
    }

    /// <summary>
    /// 解压缩配置文件
    /// </summary>
    /// <param name="data"></param>
    /// <returns></returns>
    private static string Decompress(byte[] data)
    {
        using var input = new MemoryStream(data);
        using var gz = new GZipStream(input, CompressionMode.Decompress);
        using var reader = new StreamReader(gz, Encoding.UTF8);
        return reader.ReadToEnd();
    }
}

SysConfig.cs

/// <summary>
/// 系统配置管理
/// </summary>
public static class SysConfig
{
    /// <summary>
    /// 获取配置项
    /// </summary>
    /// <param name="key"></param>
    /// <returns></returns>
    public static string? Get(string key)=> Get<string>(key);

    /// <summary>
    /// 获取配置项
    /// </summary>
    public static T? Get<T>(string key)
    {
        var value = ConfigManager.Instance.Get(key);
        if (value == null) return default;

        try
        {
            if (value is JsonElement jsonElement)
            {
                value = jsonElement.ToString();
            }
            return (T)Convert.ChangeType(value, typeof(T));
        }
        catch
        {
            return default;
        }
    }

    /// <summary>
    /// 设置配置项
    /// </summary>
    public static void Set(string key, object? value)
    {
        ConfigManager.Instance.Set(key, value);
    }

    /// <summary>
    /// 设置配置项并保存
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    public static void SetAndSave(string key, object? value)
    {
        ConfigManager.Instance.Set(key, value);
        ConfigManager.Instance.Save();
    }

    /// <summary>
    /// 保存配置
    /// </summary>
    public static void Save()
    {
        ConfigManager.Instance.Save();
    }
}

使用示例：

// 获取
SysConfig.Get("FirstConfig");
SysConfig.Get<int>("ConvertIntConfig");
SysConfig.Get<bool>("Convert:FirstBoolVal");

// 设置
SysConfig.Set("FirstConfig", "保存值");
SysConfig.Set("Convert:FirstBoolVal", true);

// 保存配置项
SysConfig.Save();

// 上述[设置]和[保存配置项]可使用下面一步完成
SysConfig.SetAndSave("ConvertIntConfig", 100);

C# Sqlite读写方案

Thu, 11 Sep 2025 00:00:00 GMT

一个简单的C#实现Sqlite数据库读写的方法嘞

优点：

简单实用，静态实现，随调随用
单例实现，合理的资源释放
Entity First，不用管表，ORM的实现
支持异步

AppDbContext.cs

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    /// <summary>
    /// 用户实体类
    /// </summary>
    public DbSet<UserEntity> Users{ get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        if (!optionsBuilder.IsConfigured)
        {
            optionsBuilder.UseSqlite("Data Source=database.db"); // 默认存储在程序根目录
        }
    }
}

SqliteSchemaUpdater.cs 这个主要是实现ORM模式，根据实体类自动CURD数据表

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;
using System.Data.Common;
using System.Text;

public static class SqliteSchemaUpdater
{
    public static void EnsureSchemaSynced(DbContext context, bool log = false)
    {
        var connection = context.Database.GetDbConnection();
        connection.Open();

        var entityTypes = context.Model.GetEntityTypes();
        var existingTables = GetExistingTableNames(connection);

        // Step 1: DROP tables that are no longer in model
        foreach (var oldTable in existingTables)
        {
            if (!entityTypes.Any(e => e.GetTableName() == oldTable))
            {
                Log($"Dropping table: {oldTable}", log);
                ExecuteNonQuery(connection, $"DROP TABLE IF EXISTS [{oldTable}];");
            }
        }

        // Step 2: CREATE or ALTER
        foreach (var entityType in entityTypes)
        {
            var tableName = entityType.GetTableName()!;
            var props = entityType.GetProperties();

            if (!existingTables.Contains(tableName))
            {
                var createSql = BuildCreateTableSql(tableName, props);
                Log($"Creating table: {tableName}", log);
                ExecuteNonQuery(connection, createSql);
            }
            else
            {
                var existingColumns = GetExistingColumnNames(connection, tableName);
                var modelColumns = props.Select(p => p.GetColumnName()).ToList();

                // Add missing columns
                foreach (var p in props)
                {
                    var columnName = p.GetColumnName();
                    if (!existingColumns.Contains(columnName))
                    {
                        var columnSql = BuildAddColumnSql(p);
                        Log($"Adding column: {columnName} to {tableName}", log);
                        ExecuteNonQuery(connection, $"ALTER TABLE [{tableName}] ADD COLUMN {columnSql};");
                    }
                }

                // Drop obsolete columns
                foreach (var oldCol in existingColumns)
                {
                    if (!modelColumns.Contains(oldCol))
                    {
                        Log($"Dropping column: {oldCol} from {tableName}", log);
                        RecreateTableWithoutColumn(connection, entityType, oldCol, log);
                    }
                }
            }
        }
    }

    private static HashSet<string> GetExistingTableNames(DbConnection conn)
    {
        var tables = new HashSet<string>();
        using var cmd = conn.CreateCommand();
        cmd.CommandText = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%';";
        using var reader = cmd.ExecuteReader();
        while (reader.Read())
            tables.Add(reader.GetString(0));
        return tables;
    }

    private static HashSet<string> GetExistingColumnNames(DbConnection conn, string tableName)
    {
        var columns = new HashSet<string>();
        using var cmd = conn.CreateCommand();
        cmd.CommandText = $"PRAGMA table_info([{tableName}]);";
        using var reader = cmd.ExecuteReader();
        while (reader.Read())
            columns.Add(reader.GetString(1));
        return columns;
    }

    private static string BuildCreateTableSql(string tableName, IEnumerable<IProperty> props)
    {
        var cols = props.Select(BuildColumnDefinition);
        return $"CREATE TABLE IF NOT EXISTS [{tableName}] ({string.Join(", ", cols)});";
    }

    private static string BuildColumnDefinition(IProperty prop)
    {
        var name = prop.GetColumnName();
        var type = prop.ClrType;
        var sqlType = GetSqliteType(type);
        var sb = new StringBuilder($"[{name}] {sqlType}");

        if (prop.IsPrimaryKey()) sb.Append(" PRIMARY KEY");
        if (prop.IsPrimaryKey() && (type == typeof(int) || type == typeof(long))) sb.Append(" AUTOINCREMENT");

        return sb.ToString();
    }

    private static string BuildAddColumnSql(IProperty prop) => BuildColumnDefinition(prop);

    private static string GetSqliteType(Type type) =>
        type == typeof(int) || type == typeof(long) ? "INTEGER" :
        type == typeof(double) || type == typeof(float) ? "REAL" :
        type == typeof(string) ? "TEXT" :
        type == typeof(bool) ? "INTEGER" :
        type == typeof(DateTime) ? "TEXT" : "TEXT";

    private static void ExecuteNonQuery(DbConnection conn, string sql)
    {
        using var cmd = conn.CreateCommand();
        cmd.CommandText = sql;
        cmd.ExecuteNonQuery();
    }

    private static void RecreateTableWithoutColumn(DbConnection conn, IEntityType entityType, string dropColumn, bool log)
    {
        var tableName = entityType.GetTableName()!;
        var tempTable = tableName + "_temp";
        var props = entityType.GetProperties().Where(p => p.GetColumnName() != dropColumn).ToList();

        Log($"Recreating table {tableName} without column {dropColumn}", log);

        // 1. Create temp table
        var createTemp = BuildCreateTableSql(tempTable, props);
        ExecuteNonQuery(conn, createTemp);

        // 2. Copy data
        var columns = string.Join(", ", props.Select(p => p.GetColumnName()));
        ExecuteNonQuery(conn, $"INSERT INTO [{tempTable}] ({columns}) SELECT {columns} FROM [{tableName}];");

        // 3. Drop original table
        ExecuteNonQuery(conn, $"DROP TABLE [{tableName}];");

        // 4. Rename temp
        ExecuteNonQuery(conn, $"ALTER TABLE [{tempTable}] RENAME TO [{tableName}];");
    }

    private static void Log(string message, bool enableLog)
    {
        if (enableLog)
            Logs.Info($"[SchemaUpdater] {message}"); // Logs类可以看我之前的日志方案文章：https://wc.sb/23
    }
}

使用示例：

首先要在App.xaml.cs中处理初始化

// App.xaml.cs

/// <summary>
/// 程序启动后事件
/// </summary>
/// <param name="e"></param>
protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);

    using var db = new AppDbContext();

    // 自动同步数据库结构，log: true 表示输出日志
    SqliteSchemaUpdater.EnsureSchemaSynced(db, log: true);

    // 下面可以写一些数据库初始化操作...

}

使用：

using var db = new AppDbContext(); // 单例实现，啥时候用啥时候创建，不用定义成全局什么的
var user = db.Users.FirstOrDefault(x=>x.Id == "xxx"); // 查数据库，ORM形式，Linq直接查
user.UserName = "李四";
db.Update(user); // 更新数据

UserEntity addUser = new UserEntity();
addUser.UserName = "张三";
db.Add(addUser); // 插入数据

db.Remove(user); // 删除数据

db.SaveChanges(); // 每次操作数据库后，都要执行这个保存操作

C# 经纬度的转换，百度、高德、腾讯、GPS互转

Thu, 26 Jun 2025 00:00:00 GMT


/// <summary>
/// 经纬度转换
/// </summary>
public static class LocationUtil
{
    private const double Pi = 3.1415926535897932384626;
    private const double A = 6378245.0;
    private const double EE = 0.00669342162296594323;
    private const double X_PI = Pi * 3000.0 / 180.0;

    /// <summary>
    /// 是否在中国区域
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static bool IsInChina(double lat, double lng)
    {
        return lng >= 72.004 && lng <= 137.8347 && lat >= 0.8293 && lat <= 55.8271;
    }

    #region GPS <=> GCJ02

    /// <summary>
    /// 将WGS84坐标转换为GCJ02坐标（中国国测局坐标）
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static (double lat, double lng) Wgs84ToGcj02(double lat, double lng)
    {
        if (!IsInChina(lat, lng)) return (lat, lng);
        var (dLat, dLng) = Delta(lat, lng);
        return (lat + dLat, lng + dLng);
    }

    /// <summary>
    /// 将GCJ02坐标转换为WGS84坐标（GPS坐标）
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static (double lat, double lng) Gcj02ToWgs84(double lat, double lng)
    {
        if (!IsInChina(lat, lng)) return (lat, lng);
        var (dLat, dLng) = Delta(lat, lng);
        return (lat - dLat, lng - dLng);
    }

    private static (double, double) Delta(double lat, double lng)
    {
        double dLat = TransformLat(lng - 105.0, lat - 35.0);
        double dLng = TransformLng(lng - 105.0, lat - 35.0);
        double radLat = lat / 180.0 * Pi;
        double magic = Math.Sin(radLat);
        magic = 1 - EE * magic * magic;
        double sqrtMagic = Math.Sqrt(magic);
        dLat = (dLat * 180.0) / ((A * (1 - EE)) / (magic * sqrtMagic) * Pi);
        dLng = (dLng * 180.0) / (A / sqrtMagic * Math.Cos(radLat) * Pi);
        return (dLat, dLng);
    }

    private static double TransformLat(double x, double y)
    {
        double ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y +
                     0.1 * x * y + 0.2 * Math.Sqrt(Math.Abs(x));
        ret += (20.0 * Math.Sin(6.0 * x * Pi) +
                20.0 * Math.Sin(2.0 * x * Pi)) * 2.0 / 3.0;
        ret += (20.0 * Math.Sin(y * Pi) +
                40.0 * Math.Sin(y / 3.0 * Pi)) * 2.0 / 3.0;
        ret += (160.0 * Math.Sin(y / 12.0 * Pi) +
                320.0 * Math.Sin(y * Pi / 30.0)) * 2.0 / 3.0;
        return ret;
    }

    private static double TransformLng(double x, double y)
    {
        double ret = 300.0 + x + 2.0 * y + 0.1 * x * x +
                     0.1 * x * y + 0.1 * Math.Sqrt(Math.Abs(x));
        ret += (20.0 * Math.Sin(6.0 * x * Pi) +
                20.0 * Math.Sin(2.0 * x * Pi)) * 2.0 / 3.0;
        ret += (20.0 * Math.Sin(x * Pi) +
                40.0 * Math.Sin(x / 3.0 * Pi)) * 2.0 / 3.0;
        ret += (150.0 * Math.Sin(x / 12.0 * Pi) +
                300.0 * Math.Sin(x / 30.0 * Pi)) * 2.0 / 3.0;
        return ret;
    }

    #endregion

    #region GCJ02 <=> BD09

    /// <summary>
    /// 将GCJ02坐标转换为BD09坐标（百度坐标）
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static (double lat, double lng) Gcj02ToBd09(double lat, double lng)
    {
        double x = lng, y = lat;
        double z = Math.Sqrt(x * x + y * y) + 0.00002 * Math.Sin(y * X_PI);
        double theta = Math.Atan2(y, x) + 0.000003 * Math.Cos(x * X_PI);
        double bdLng = z * Math.Cos(theta) + 0.0065;
        double bdLat = z * Math.Sin(theta) + 0.006;
        return (bdLat, bdLng);
    }

    /// <summary>
    /// 将BD09坐标转换为GCJ02坐标（百度坐标转国测局坐标）
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static (double lat, double lng) Bd09ToGcj02(double lat, double lng)
    {
        double x = lng - 0.0065, y = lat - 0.006;
        double z = Math.Sqrt(x * x + y * y) - 0.00002 * Math.Sin(y * X_PI);
        double theta = Math.Atan2(y, x) - 0.000003 * Math.Cos(x * X_PI);
        double ggLng = z * Math.Cos(theta);
        double ggLat = z * Math.Sin(theta);
        return (ggLat, ggLng);
    }

    #endregion

    #region WGS84 <=> BD09 (组合)

    /// <summary>
    /// 将WGS84坐标转换为BD09坐标（百度坐标）
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static (double lat, double lng) Wgs84ToBd09(double lat, double lng)
    {
        var (gLat, gLng) = Wgs84ToGcj02(lat, lng);
        return Gcj02ToBd09(gLat, gLng);
    }

    /// <summary>
    /// 将BD09坐标转换为WGS84坐标（GPS坐标）
    /// </summary>
    /// <param name="lat">纬度(X，100多那个)</param>
    /// <param name="lng">经度(Y，30多那个)</param>
    /// <returns></returns>
    public static (double lat, double lng) Bd09ToWgs84(double lat, double lng)
    {
        var (gLat, gLng) = Bd09ToGcj02(lat, lng);
        return Gcj02ToWgs84(gLat, gLng);
    }

    #endregion
}

使用Docker自动编译发布Net Core项目

Tue, 18 Feb 2025 00:00:00 GMT

前言

项目是使用的Net Core 2.2的老项目，而编译服务器是Debian12，Debian12已不再支持Net Core 2.2 SDK所以无法直接编译，故使用Docker实现编译项目。

环境介绍

系统版本：Debian GNU/Linux 12 (bookworm) 代码管理：Gitea 23.0.0 代码集成：Jenkins 2.492.1

Jenkins 配置

~~主要是用来触发编译，感觉随便用一个WebHook就可以~~

1、安装必要插件

在系统管理->插件管理->Available plugins中搜索Generic Webhook Trigger Plugin并安装

2、新建任务流程

新建一个自由风格的任务流程

3、配置任务流程

在源码管理中配置代码仓库

在Triggers中勾选Generic Webhook Trigger，并设置下方Token，其他不用操作

在Build Steps中添加执行 shell步骤，用来执行命令(也可以直接写，不过我还是喜欢单独写文件中执行)

填写完毕后保存。

Gitea 配置

配置webhook，触发jenkins构建

1、添加Web钩子

在仓库中的设置->Web钩子中，点击右上角Web钩子按钮，选择Gitea添加；配置目标Url，格式为Jenkins地址 + __generic-webhook-trigger/invoke?token=__ + Token，例如http://192.168.1.100:8080/generic-webhook-trigger/invoke?token=123456

脚本编写

编写Dockerfile与编译脚本

Dockerfile文件

下述流程先使用SDK进行编译发布，然后在RunTime中运行项目；因为微软官方提供的RunTime并无libgdiplus，所以项目中使用图形的地方都会报错，这里咱们修改下镜像源，手动安装libgdiplus，如果项目还需安装其他的，自行追加安装即可。

# 使用 .NET Core SDK 镜像来构建项目
FROM mcr.microsoft.com/dotnet/core/sdk:2.2 AS build

# 设置工作目录
WORKDIR /app

# 复制文件
COPY . ./

# 恢复 Test_Project 项目的依赖项
RUN dotnet restore Test_Project.csproj

# 发布 Test_Project 项目
RUN dotnet publish Test_Project.csproj -c Release -o /app/publish

# 使用 .NET Core 运行时镜像来运行应用程序
FROM mcr.microsoft.com/dotnet/core/aspnet:2.2 AS base

# 设置工作目录
WORKDIR /app

# 暴漏端口
EXPOSE 11081

# 修复软件源并安装 libgdiplus
RUN echo "deb http://mirrors.tuna.tsinghua.edu.cn/debian-elts stretch main contrib non-free" > /etc/apt/sources.list \
    && curl -fsSL https://deb.freexian.com/extended-lts/archive-key.gpg -o /tmp/elts-archive-key.gpg \
    && mv /tmp/elts-archive-key.gpg /etc/apt/trusted.gpg.d/freexian-archive-extended-lts.gpg \
    && apt-get update && apt-get install -y libgdiplus \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

# 将发布后的 Web API 文件复制到运行时容器中
COPY --from=build /app/publish .

# 配置应用程序 URL
ENV ASPNETCORE_URLS=http://*:11081

# 设置容器的启动命令
ENTRYPOINT ["dotnet", "Test_Project.dll"]

编译脚本

下述脚本主要是将配置文件appsettings.json和Dockerfile复制到Jenkins编译的项目中(Jenkens需映射宿主机项目路径)，然后构建新镜像并删除旧容器(如果有)，最后运行新容器；启动容器时我做了重启策略--restart=on-failure:3，运行报错退出后自动重启，重启次数最多3次，然后映射资源目录wwwroot和日志目录logs，便于直接在宿主机上查看。

#!/bin/bash

set -e

# 变量
SRC_DIR="/home/project/Test_Project"
DEST_DIR="."
DOCKER_IMAGE="test_project"
DOCKER_CONTAINER="Test_Project"
PORT_MAPPING="11081:11081"

# 检查目录和文件
[ -d "$SRC_DIR" ] || { echo "错误: 目录 $SRC_DIR 不存在！"; exit 1; }
[ -f "$SRC_DIR/Dockerfile" ] || { echo "错误: Dockerfile 不存在！"; exit 1; }
mkdir -p "$DEST_DIR"
[ -f "$SRC_DIR/appsettings.json" ] && cp "$SRC_DIR/appsettings.json" "$DEST_DIR/"

# 确保 Api 目录结构完整
mkdir -p "$SRC_DIR/Api/wwwroot" "$SRC_DIR/Api/logs"

# 构建 Docker 镜像
cp "$SRC_DIR/Dockerfile" .
docker build -t "$DOCKER_IMAGE" .

# 移除旧容器
docker rm -f "$DOCKER_CONTAINER" 2>/dev/null || true

# 运行新容器
docker run -d -p "$PORT_MAPPING" --name "$DOCKER_CONTAINER" \
  --restart=on-failure:3 \
  -v "$SRC_DIR/Api/wwwroot:/app/wwwroot" \
  -v "$SRC_DIR/Api/logs:/app/logs" \
  "$DOCKER_IMAGE"

处理流程

提交代码 -> Gitea WebHook触发Jenkins构建 -> Jenkins拉取Gitea代码 -> Jenkins执行编译脚本 ->脚本复制配置文件与Dockerfile -> 脚本使用Dockerfile内容构建镜像 -> Dockerfile先使用SDK进行编译发布 -> Docker使用AspNet作为运行环境并构建镜像 -> 脚本删除旧容器(如果有) ->脚本启动新容器