场景

目前一个项目中数据持久化采用EF Core + MySQL，使用CodeFirst模式开发，并且对数据进行了分库，按照目前颗粒度分完之后，大概有一两百个库，每个库的数据都是相互隔离的。

借鉴了Github上一个开源的仓库 arch/UnitOfWork 实现UnitOfWork，核心操作就是每个api请求的时候带上库名，在执行CRUD之前先将DbContext切换到目标数据库，我们在切换数据库的时候加了一些操作，如检查数据库是否已创建、检查连接是否可用、判断是否需要 表结构迁移 等

  1. /// <summary>
  2. /// 切换数据库 这要求数据库在同一台机器上 注意:这只适用于MySQL。
  3. /// </summary>
  4. /// <param name="database">目标数据库</param>
  5. public void ChangeDatabase(string database)
  6. {
  7.     // 检查连接
  8.     ......
  10.     // 检查数据库是否创建
  11.     ......
  13.     var connection = _context.Database.GetDbConnection();
  14.     if (connection.State.HasFlag(ConnectionState.Open))
  15.     {
  16.         connection.ChangeDatabase(database);
  17.     }
  18.     else
  19.     {
  20.         var connectionString = Regex.Replace(connection.ConnectionString.Replace(" ", ""), @"(?<=[Dd]atabase=)\w+(?=;)", database, RegexOptions.Singleline);
  21.         connection.ConnectionString = connectionString;
  22.     }
  24.     // 判断是否需要执行表结构迁移
  25.     if(_context..Database.GetPendingMigrations().Any())
  26.     {
  27.         //自定义的迁移的一些逻辑
  28.         _migrateExecutor.Migrate(_context);
  29.     }
  30. }

但是当多个操作同时对一个库进行Migrate的时候，就会出现问题，比如“新增一张表”的操作已经被第一个迁移执行过了，第二个执行的迁移并不知道已经执行过了Migrate，就会报错表已存在。

于是考虑在执行Migrate的时候，加入一个锁的机制，对当前数据库执行Migrate之前先获取锁，然后再来决定接下来的操作。由于边有的服务无法访问Redis，这里使用数据库来实现锁的机制，当然用Redis来实现更好，加入锁的机制只是一种解决问题的思路。

利用数据库实现迁移锁

1. 新增 MigrationLocks 表来实现迁移锁

  • 锁的操作不依赖DbContext实例
  • 在执行Migrate之前，尝试获取一个锁，在获取锁之前，如果表不存在则创建 
    1. CREATE TABLE IF NOT EXISTS MigrationLocks (
    2.     LockName VARCHAR(255) PRIMARY KEY,
    3.     LockedAt DATETIME NOT NULL
    4. );
  • 成功往表中插入一条记录，视为获取锁成功，主键为需要迁移的库的名称 
    1. INSERT INTO MigrationLocks (LockName, LockedAt) VALUES (@database, NOW());
  • 迁移完成后，删除这条记录，视为释放锁成功； 
    1. DELETE FROM MigrationLocks WHERE LockName = @database;
  • 为防止 “死锁” 发生，每次尝试获取锁之前，会对锁的状态进行检查，释放超过5分钟的锁（正常来说，上一个迁移的执行时间不会超过5分钟）。 
    1. SELECT COUNT(*) FROM MigrationLocks WHERE LockName = @database AND LockedAt > NOW() - INTERVAL 5 MINUTE;

2. 封装一下MigrateLock的实现

  1. /// <summary>
  2. /// 迁移锁
  3. /// </summary>
  4. public interface IMigrateLock
  5. {
  6.     /// <summary>
  7.     /// 尝试获取锁
  8.     /// </summary>
  9.     /// <param name="connection"></param>
  10.     /// <returns></returns>
  11.     bool TryAcquireLock(IDbConnection connection);
  13.     /// <summary>
  14.     /// 尝试获取锁
  15.     /// </summary>
  16.     /// <param name="connection"></param>
  17.     /// <returns></returns>
  18.     Task<bool> TryAcquireLockAsync(IDbConnection connection);
  20.     /// <summary>
  21.     /// 释放锁
  22.     /// </summary>
  23.     void ReleaseLock(IDbConnection connection);
  25.     /// <summary>
  26.     /// 释放锁
  27.     /// </summary>
  28.     /// <returns></returns>
  29.     Task ReleaseLockAsync(IDbConnection connection);
  30. }
  32. /// <summary>
  33. /// 迁移锁
  34. /// </summary>
  35. public class MigrateLock : IMigrateLock
  36. {
  37.     private readonly ILogger<MigrateLock> _logger;
  39.     public MigrateLock(ILogger<MigrateLock> logger)
  40.     {
  41.         _logger = logger;
  42.     }
  44.     private const string CreateTableSql = @"
  45.         CREATE TABLE IF NOT EXISTS MigrationLocks (
  46.             LockName VARCHAR(255) PRIMARY KEY,
  47.             LockedAt DATETIME NOT NULL
  48.         );";
  50.     private const string CheckLockedSql = "SELECT COUNT(*) FROM MigrationLocks WHERE LockName = @database AND LockedAt > NOW() - INTERVAL 5 MINUTE;";
  52.     private const string AcquireLockSql = "INSERT INTO MigrationLocks (LockName, LockedAt) VALUES (@database, NOW());";
  54.     private const string ReleaseLockSql = "DELETE FROM MigrationLocks WHERE LockName = @database;";
  56.     /// <summary>
  57.     /// 尝试获取锁
  58.     /// </summary>
  59.     /// <param name="connection"></param>
  60.     /// <returns></returns>
  61.     public bool TryAcquireLock(IDbConnection connection)
  62.     {
  63.         try
  64.         {
  65.             CheckLocked(connection);
  67.             var result = connection.Execute(AcquireLockSql, new { database = connection.Database });
  68.             if (result == 1)
  69.             {
  70.                 _logger.LogInformation("Lock acquired: {LockName}", connection.Database);
  72.                 return true;
  73.             }
  75.             _logger.LogWarning("Failed to acquire lock: {LockName}", connection.Database);
  77.             return false;
  78.         }
  79.         catch (Exception ex)
  80.         {
  81.             if (ex.Message.StartsWith("Duplicate"))
  82.             {
  83.                 _logger.LogWarning("Failed acquiring lock due to duplicate entry: {LockName}", connection.Database);
  84.             }
  85.             else
  86.             {
  87.                 _logger.LogError(ex, "Error acquiring lock: {LockName}", connection.Database);
  88.             }
  90.             return false;
  91.         }
  92.     }
  94.     /// <summary>
  95.     /// 尝试获取锁
  96.     /// </summary>
  97.     /// <param name="connection"></param>
  98.     /// <returns></returns>
  99.     public async Task<bool> TryAcquireLockAsync(IDbConnection connection)
  100.     {
  101.         try
  102.         {
  103.             await CheckLockedAsync(connection);
  105.             var result = await connection.ExecuteAsync(AcquireLockSql, new { database = connection.Database });
  106.             if (result == 1)
  107.             {
  108.                 _logger.LogInformation("Lock acquired: {LockName}", connection.Database);
  110.                 return true;
  111.             }
  113.             _logger.LogWarning("Failed to acquire lock: {LockName}", connection.Database);
  115.             return false;
  116.         }
  117.         catch (Exception ex)
  118.         {
  119.             if (ex.Message.StartsWith("Duplicate"))
  120.             {
  121.                 _logger.LogWarning("Failed acquiring lock due to duplicate entry: {LockName}", connection.Database);
  122.             }
  123.             else
  124.             {
  125.                 _logger.LogError(ex, "Error acquiring lock: {LockName}", connection.Database);
  126.             }
  128.             return false;
  129.         }
  130.     }
  132.     /// <summary>
  133.     /// 释放锁
  134.     /// </summary>
  135.     public void ReleaseLock(IDbConnection connection)
  136.     {
  137.         try
  138.         {
  139.             connection.ExecuteAsync(ReleaseLockSql, new { database = connection.Database });
  140.             _logger.LogInformation("Lock released: {LockName}", connection.Database);
  141.         }
  142.         catch (Exception ex)
  143.         {
  144.             _logger.LogError(ex, "Error releasing lock: {LockName}", connection.Database);
  145.         }
  146.     }
  148.     /// <summary>
  149.     /// 释放锁
  150.     /// </summary>
  151.     public async Task ReleaseLockAsync(IDbConnection connection)
  152.     {
  153.         try
  154.         {
  155.             await connection.ExecuteAsync(ReleaseLockSql, new { database = connection.Database });
  156.             _logger.LogInformation("Lock released: {LockName}", connection.Database);
  157.         }
  158.         catch (Exception ex)
  159.         {
  160.             _logger.LogError(ex, "Error releasing lock: {LockName}", connection.Database);
  161.         }
  162.     }
  164.     /// <summary>
  165.     /// 检查锁
  166.     /// </summary>
  167.     private void CheckLocked(IDbConnection connection)
  168.     {
  169.         connection.Execute(CreateTableSql); 
  171.         var databaseParam = new
  172.         {
  173.             database = connection.Database
  174.         };
  176.         var lockExists = connection.QueryFirstOrDefault<int>(CheckLockedSql, databaseParam);
  177.         if (lockExists <= 0)
  178.         {
  179.             return;
  180.         }
  182.         _logger.LogWarning("Lock exists and is older than 5 minutes. Releasing old lock.");
  183.         connection.Execute(ReleaseLockSql, databaseParam);
  184.     }
  186.     /// <summary>
  187.     /// 检查锁
  188.     /// </summary>
  189.     private async Task CheckLockedAsync(IDbConnection connection)
  190.     {
  191.         await connection.ExecuteAsync(CreateTableSql);
  193.         var databaseParam = new
  194.         {
  195.             database = connection.Database
  196.         };
  198.         var lockExists = await connection.QueryFirstOrDefaultAsync<int>(CheckLockedSql, databaseParam);
  199.         if (lockExists <= 0)
  200.         {
  201.             return;
  202.         }
  204.         _logger.LogWarning("Lock exists and is older than 5 minutes. Releasing old lock.");
  205.         await connection.ExecuteAsync(ReleaseLockSql, databaseParam);
  206.     }
  207. }

3. 封装一下MigrateExecutor的实现

  1. /// <summary>
  2. /// 数据库迁移执行器
  3. /// </summary>
  4. public interface IMigrateExcutor
  5. {
  6.     /// <summary>
  7.     /// 执行迁移
  8.     /// </summary>
  9.     /// <param name="dbContext"></param>
  10.     void Migrate(DbContext dbContext);
  12.     /// <summary>
  13.     /// 执行迁移
  14.     /// </summary>
  15.     /// <param name="dbContext"></param>
  16.     /// <returns></returns>
  17.     Task MigrateAsync(DbContext dbContext);
  19.     /// <summary>
  20.     /// 并发场景执行迁移
  21.     /// </summary>
  22.     /// <param name="dbContext"></param>
  23.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  24.     void ConcurrentMigrate(DbContext dbContext, bool wait = true);
  26.     /// <summary>
  27.     /// 并发场景执行迁移
  28.     /// </summary>
  29.     /// <param name="dbContext"></param>
  30.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  31.     /// <returns></returns>
  32.     Task ConcurrentMigrateAsync(DbContext dbContext, bool wait = true);
  34.     /// <summary>
  35.     /// 并发场景执行迁移
  36.     /// </summary>
  37.     /// <param name="dbContext"></param>
  38.     /// <param name="connection"></param>
  39.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  40.     void ConcurrentMigrate(DbContext dbContext, IDbConnection connection, bool wait = true);
  42.     /// <summary>
  43.     /// 并发场景执行迁移
  44.     /// </summary>
  45.     /// <param name="dbContext"></param>
  46.     /// <param name="connection"></param>
  47.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  48.     Task ConcurrentMigrateAsync(DbContext dbContext, IDbConnection connection, bool wait = true);
  49. }
  51. /// <summary>
  52. /// 数据库迁移执行器
  53. /// </summary>
  54. public class MigrateExcutor : IMigrateExcutor
  55. {
  56.     private readonly IMigrateLock _migrateLock;
  57.     private readonly ILogger<MigrateExcutor> _logger;
  59.     public MigrateExcutor(
  60.         IMigrateLock migrateLock,
  61.         ILogger<MigrateExcutor> logger)
  62.     {
  63.         _migrateLock = migrateLock;
  64.         _logger = logger;
  65.     }
  67.     /// <summary>
  68.     /// 执行迁移
  69.     /// </summary>
  70.     /// <param name="dbContext"></param>
  71.     /// <returns></returns>
  72.     public void Migrate(DbContext dbContext)
  73.     {
  74.         try
  75.         {
  76.             if (dbContext.Database.GetPendingMigrations().Any())
  77.             {
  78.                 dbContext.Database.Migrate();
  79.             }
  80.         }
  81.         catch (Exception e)
  82.         {
  83.             _logger.LogError(e, "Migration failed");
  85.             HandleError(dbContext, e);
  86.         }
  87.     }
  89.     /// <summary>
  90.     /// 执行迁移
  91.     /// </summary>
  92.     /// <param name="dbContext"></param>
  93.     /// <returns></returns>
  94.     public async Task MigrateAsync(DbContext dbContext)
  95.     {
  96.         try
  97.         {
  98.             if ((await dbContext.Database.GetPendingMigrationsAsync()).Any())
  99.             {
  100.                 await dbContext.Database.MigrateAsync();
  101.             }
  102.         }
  103.         catch (Exception e)
  104.         {
  105.             _logger.LogError(e, "Migration failed");
  107.             await HandleErrorAsync(dbContext, e);
  108.         }
  109.     }
  111.     /// <summary>
  112.     /// 并发场景执行迁移
  113.     /// </summary>
  114.     /// <param name="dbContext"></param>
  115.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  116.     /// <returns></returns>
  117.     public void ConcurrentMigrate(DbContext dbContext, bool wait = true)
  118.     {
  119.         if (!dbContext.Database.GetPendingMigrations().Any())
  120.         {
  121.             return;
  122.         }
  124.         using var connection = MySqlConnectionHelper.CreateConnection(dbContext.Database.GetDbConnection().Database);
  126.         ConcurrentMigrate(dbContext, connection, wait);
  127.     }
  129.     /// <summary>
  130.     /// 并发场景执行迁移
  131.     /// </summary>
  132.     /// <param name="dbContext"></param>
  133.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  134.     /// <returns></returns>
  135.     public async Task ConcurrentMigrateAsync(DbContext dbContext, bool wait = true)
  136.     {
  137.         if ((await dbContext.Database.GetPendingMigrationsAsync()).Any())
  138.         {
  139.             return;
  140.         }
  142.         await using var connection = await MySqlConnectionHelper.CreateConnectionAsync(dbContext.Database.GetDbConnection().Database);
  144.         await ConcurrentMigrateAsync(dbContext, connection, wait);
  145.     }
  147.     /// <summary>
  148.     /// 并发场景执行迁移（供数据同步相关服务使用，”迁移锁“ 使用传入的 <see cref="IDbConnection"/> 对象来完成）
  149.     /// </summary>
  150.     /// <param name="dbContext"></param>
  151.     /// <param name="connection"></param>
  152.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  153.     public void ConcurrentMigrate(DbContext dbContext, IDbConnection connection, bool wait = true)
  154.     {
  155.         if (!dbContext.Database.GetPendingMigrations().Any())
  156.         {
  157.             return;
  158.         }
  160.         while (true)
  161.         {
  162.             if (_migrateLock.TryAcquireLock(connection))
  163.             {
  164.                 try
  165.                 {
  166.                     Migrate(dbContext);
  168.                     break;
  169.                 }
  170.                 finally
  171.                 {
  172.                     _migrateLock.ReleaseLock(connection);
  173.                 }
  174.             }
  176.             if (wait)
  177.             {
  178.                 _logger.LogWarning("Migration is locked, wait for 2 seconds");
  179.                 Thread.Sleep(20000);
  181.                 continue;
  182.             }
  184.             _logger.LogInformation("Migration is locked, skip");
  185.         }
  186.     }
  188.     /// <summary>
  189.     /// 并发场景执行迁移（供数据同步相关服务使用，”迁移锁“ 使用传入的 <see cref="IDbConnection"/> 对象来完成）
  190.     /// </summary>
  191.     /// <param name="dbContext"></param>
  192.     /// <param name="connection"></param>
  193.     /// <param name="wait">是否等待至正在进行中的迁移完成</param>
  194.     public async Task ConcurrentMigrateAsync(DbContext dbContext, IDbConnection connection, bool wait = true)
  195.     {
  196.         if ((await dbContext.Database.GetPendingMigrationsAsync()).Any())
  197.         {
  198.             return;
  199.         }
  201.         while (true)
  202.         {
  203.             if (await _migrateLock.TryAcquireLockAsync(connection))
  204.             {
  205.                 try
  206.                 {
  207.                     await MigrateAsync(dbContext);
  208.                     break;
  209.                 }
  210.                 finally
  211.                 {
  212.                     await _migrateLock.ReleaseLockAsync(connection);
  213.                 }
  214.             }
  216.             if (wait)
  217.             {
  218.                 _logger.LogWarning("Migration is locked, wait for 2 seconds");
  219.                 Thread.Sleep(20000);
  221.                 continue;
  222.             }
  224.             _logger.LogInformation("Migration is locked, skip");
  226.             break;
  227.         }
  228.     }
  230.     private void HandleError(DbContext dbContext, Exception e)
  231.     {
  232.         var needChangeList = dbContext.Database.GetPendingMigrations().ToList();
  233.         var allChangeList = dbContext.Database.GetMigrations().ToList();
  234.         var hasChangeList = dbContext.Database.GetAppliedMigrations().ToList();
  236.         if (needChangeList.Count + hasChangeList.Count > allChangeList.Count)
  237.         {
  238.             int errIndex = allChangeList.Count - needChangeList.Count;
  240.             if (hasChangeList.Count - 1 == errIndex && hasChangeList[errIndex] != needChangeList[0])
  241.             {
  242.                 int index = needChangeList[0].IndexOf("_", StringComparison.Ordinal);
  243.                 string errSuffix = needChangeList[0].Substring(index, needChangeList[0].Length - index);
  244.                 if (hasChangeList[errIndex].EndsWith(errSuffix))
  245.                 {
  246.                     dbContext.Database.ExecuteSqlRaw($"Update __EFMigrationsHistory set MigrationId = '{needChangeList[0]}' where MigrationId = '{hasChangeList[errIndex]}'");
  247.                     dbContext.Database.Migrate();
  248.                 }
  249.                 else
  250.                 {
  251.                     throw e;
  252.                 }
  253.             }
  254.             else
  255.             {
  256.                 throw e;
  257.             }
  258.         }
  259.         else
  260.         {
  261.             throw e;
  262.         }
  264.         _logger.LogInformation("Migration failed, but success on second try.");
  265.     }
  267.     private async Task HandleErrorAsync(DbContext dbContext, Exception e)
  268.     {
  269.         var needChangeList = (await dbContext.Database.GetPendingMigrationsAsync()).ToList();
  270.         var allChangeList = dbContext.Database.GetMigrations().ToList();
  271.         var hasChangeList = (await dbContext.Database.GetAppliedMigrationsAsync()).ToList();
  273.         if (needChangeList.Count + hasChangeList.Count > allChangeList.Count)
  274.         {
  275.             int errIndex = allChangeList.Count - needChangeList.Count;
  277.             if (hasChangeList.Count - 1 == errIndex && hasChangeList[errIndex] != needChangeList[0])
  278.             {
  279.                 int index = needChangeList[0].IndexOf("_", StringComparison.Ordinal);
  280.                 string errSuffix = needChangeList[0].Substring(index, needChangeList[0].Length - index);
  281.                 if (hasChangeList[errIndex].EndsWith(errSuffix))
  282.                 {
  283.                     await dbContext.Database.ExecuteSqlRawAsync($"Update __EFMigrationsHistory set MigrationId = '{needChangeList[0]}' where MigrationId = '{hasChangeList[errIndex]}'");
  284.                     await dbContext.Database.MigrateAsync();
  285.                 }
  286.                 else
  287.                 {
  288.                     throw e;
  289.                 }
  290.             }
  291.             else
  292.             {
  293.                 throw e;
  294.             }
  295.         }
  296.         else
  297.         {
  298.             throw e;
  299.         }
  301.         _logger.LogInformation("Migration failed, but success on second try.");
  302.     }
  303. }

EntityFramework Core并发迁移解决方案的更多相关文章

  1. EntityFramework Core并发深挖详解，一纸长文，你准备好看完了吗？

    前言 之前有关EF并发探讨过几次,但是呢,博主感觉还是有问题,为什么会觉得有问题,其实就是理解不够透彻罢了,于是在项目中都是用的存储过程或者SQL语句来实现,利用放假时间好好补补EF Core并发的问 ...

  2. EntityFramework Core并发导致显示插入主键问题

    前言 之前讨论过EntityFramework Core中并发问题,按照官网所给并发冲突解决方案以为没有什么问题,但是在做单元测试时发现too young,too siimple,下面我们一起来看看. ...

  3. EntityFramework Core并发导致显式插入主键问题

    前言 之前讨论过EntityFramework Core中并发问题,按照官网所给并发冲突解决方案以为没有什么问题,但是在做单元测试时发现too young,too simple,下面我们一起来看看. ...

  4. EntityFramework Core解决并发详解

    前言 对过年已经无感,不过还是有很多闲暇时间来学学东西,这一点是极好的,好了,本节我们来讲讲EntityFramewoek Core中的并发问题. 话题(EntityFramework Core并发) ...

  5. EntityFramework Core高并发深挖详解，一纸长文，你准备好了吗？

    前言 之前有关EF并发探讨过几次,但是呢,博主感觉还是有问题,为什么会觉得有问题,其实就是理解不够透彻罢了,于是在项目中都是用的存储过程或者SQL语句来实现,利用放假时间好好补补EF Core并发的问 ...

  6. EntityFramework Core迁移时出现数据库已存在对象问题解决方案

    前言 刚开始接触EF Core时本着探索的精神去搞,搞着搞着发现出问题了,后来就一直没解决,觉得很是不爽,借着周末好好看看这块内容. EntityFramework Core迁移出现对象在数据库中已存 ...

  7. Cookies 初识 Dotnetspider EF 6.x、EF Core实现dynamic动态查询和EF Core注入多个上下文实例池你知道有什么问题？ EntityFramework Core 运行dotnet ef命令迁移背后本质是什么？（EF Core迁移原理）

    Cookies   1.创建HttpCookies Cookie=new HttpCookies("CookieName");2.添加内容Cookie.Values.Add(&qu ...

  8. EntityFramework Core 运行dotnet ef命令迁移背后本质是什么？（EF Core迁移原理）

    前言 终于踏出第一步探索EF Core原理和本质,过程虽然比较漫长且枯燥乏味还得反复论证,其中滋味自知,EF Core的强大想必不用我再过多废话,有时候我们是否思考过背后到底做了些什么,到底怎么实现的 ...

  9. EntityFramework Core 迁移忽略主外键关系

    前言 本文来源于一位公众号童鞋私信我的问题,在我若加思索后给出了其中一种方案,在此之前我也思考过这个问题,借此机会我稍微看了下,目前能够想到的也只是本文所述方案. 为何要忽略主外键关系 我们不仅疑惑为 ...

  10. EntityFramework Core 3多次Include导致查询性能低之解决方案

    前言 上述我们简单讲解了几个小问题,这节我们再来看看如标题EF Core中多次Include导致出现性能的问题,废话少说,直接开门见山. EntityFramework Core 3多次Include ...

随机推荐

  1. Python win11 安装lxml 失败

    如果你有一个项目执行了requirements后,一直提示lxml失败,解决步骤如下 1.尝试升级pip python.exe -m pip install --upgrade pip 2.尝试下载包 ...

  2. 自己在本地搭建 git 版本仓库服务器

    请确保你安装了 git 的图形化工具和 git 软件 首先先创建一个目录作为你的项目工程目录,比如 e:/gitTest 其次右键 git init. 然后指定一个 git 服务器目录,例如:e:/g ...

  3. c++ 快速复习第一部份

    去年有事无事学过一c++ ,,由于工作用不上,学来没有用,所以学得乱七八的,最近需要复习一下,因为最近想学习一下硬 件相关 第一   引用头文件和自定义头 #include <iostream& ...

  4. scratch源码下载 | 超大太空游戏【80MB】

    按方向键或AWSD键控制角色移动,按空格键或X键攻击. 程序超级大,共80MB,耐心等待加载. 截图: 点击下载源码 更多源码访问:小虎鲸scratch资源站

  5. 【Web】 通过浏览器打开本地应用程序

    首先需要编写注册表: 以Steam为例: "C:\Program Files (x86)\Steam\Steam.exe" 然后编写注册表: Windows Registry Ed ...

  6. 【H5】13 表单 其二 如何构造

    有了基础知识,我们现在更详细地了解了用于为表单的不同部分提供结构和意义的元素. 前提条件: 基本的计算机能力, 和基本的 对HTML的理解. 目标: 要理解如何构造HTML表单并赋予它们语义,以便它们 ...

  7. 【Redis】04 配置文件分析

    配置文件Redis.conf注释信息: 1.启动项: 启动Redis要求必须加上配置文件redis.conf路径作为第一参数加载 文档样例: ./redis-server /path/to/redis ...

  8. 2024-08-03：用go语言，给定一个从 0 开始的字符串数组 `words`， 我们定义一个名为 `isPrefixAndSuffix` 的布尔函数，该函数接受两个字符串参数 `str1` 和

    2024-08-03:用go语言,给定一个从 0 开始的字符串数组 words, 我们定义一个名为 isPrefixAndSuffix 的布尔函数,该函数接受两个字符串参数 str1 和 str2. ...

  9. 什么是3D扫描技术？

    相关: https://www.bilibili.com/video/BV1fN4y1z7uD/?vd_source=f1d0f27367a99104c397918f0cf362b7 接触式:就是使用 ...

  10. 【转载】 DQN玩Atari游戏安装atari环境bug指南

    版权声明:本文为CSDN博主「好程序不脱发」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明.原文链接:https://blog.csdn.net/ningmengzh ...