在上一篇中我们主要介绍如何在Asp.Net Core中同步Kafka消息,通过上一篇的操作我们发现上面一篇中介绍的只能够进行简单的首发kafka消息并不能够消息重发、重复消费、乐观锁冲突等问题,这些问题在实际的生产环境中是非常要命的,如果在消息的消费方没有做好必须的幂等性操作,那么消费者重复消费的问题会比较严重的,另外对于消息的生产者来说,记录日志的方式也不是足够友好,很多时候在后台监控程序中我们需要知道记录更多的关于消息的分区、偏移等更多的消息。而在消费者这边我们更多的需要去解决发送方发送重复消息,以及面对乐观锁冲突的时候该怎么解决这些问题,当然代码中的这些方案都是我们在实际生产中摸索出来的一些方案,当然这些都是需要后续进行进一步优化的,这里我们将分别就生产者和消费者中出现的问题来进行分析和说明。

 图一 消费者方几乎同一时刻接收到两条同样的Kafka消息(Grafana监控)

  一 生产者方  

  1. using System;
  2. using System.ComponentModel.DataAnnotations;
  3. using System.Runtime.CompilerServices;
  4. using System.Threading.Tasks;
  5. using Abp.Dependency;
  6. using Confluent.Kafka;
  7. using JetBrains.Annotations;
  8. using Microsoft.Extensions.Configuration;
  9. using Microsoft.Extensions.Logging;
  10. using Newtonsoft.Json;
  11. using Sunlight.Kafka.Abstractions;
  12.  
  13. [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
  14.  
  15. namespace Sunlight.Kafka {
  16. /// <summary>
  17. /// Kafka 生产者的 Domain Service
  18. /// </summary>
  19. public class KafkaProducer : ISingletonDependency, IDisposableDependencyObjectWrapper<IProducer<string, string>>, IMessageProducer {
  20. private readonly IConfiguration _config;
  21. private readonly ILogger<KafkaProducer> _logger;
  22. private readonly IProducer<string, string> _producer;
  23.  
  24. /// <summary>
  25. /// 构造 <see cref="KafkaProducer"/>
  26. /// </summary>
  27. /// <param name="config"></param>
  28. /// <param name="logger"></param>
  29. public KafkaProducer(IConfiguration config,
  30. ILogger<KafkaProducer> logger) {
  31. _config = config;
  32. _logger = logger;
  33.  
  34. var producerConfig = new ProducerConfig {
  35. BootstrapServers = _config.GetValue<string>("Kafka:BootstrapServers"),
  36. MessageTimeoutMs = _config.GetValue<int>("Kafka:MessageTimeoutMs")
  37. };
  38.  
  39. var builder = new ProducerBuilder<string, string>(producerConfig);
  40. _producer = builder.Build();
  41. Object = _producer;
  42. }
  43.  
  44. /// <summary>
  45. /// 发送事件
  46. /// </summary>
  47. /// <param name="event"></param>
  48. public void Produce(IIntegrationEvent @event) {
  49. ProduceAsync(@event).GetAwaiter().GetResult();
  50. }
  51.  
  52. /// <summary>
  53. /// 发送事件
  54. /// </summary>
  55. /// <param name="event"></param>
  56. public async Task ProduceAsync(IIntegrationEvent @event) {
  57. await ProduceAsync(@event, @event.GetType().Name);
  58. }
  59.  
  60. /// <inheritdoc />
  61. public async Task ProduceAsync(IIntegrationEvent @event, [NotNull] string eventName) {
  62. if (string.IsNullOrEmpty(eventName)) {
  63. throw new ArgumentNullException(nameof(eventName));
  64. }
  65.  
  66. var topic = _config.GetValue<string>($"Kafka:Topics:{eventName}");
  67. if (string.IsNullOrEmpty(topic)) {
  68. throw new NullReferenceException("topic不能为空");
  69. }
  70. var key = Guid.NewGuid().ToString();
  71. try {
  72. var json = JsonConvert.SerializeObject(@event);
  73. var dr = await _producer.ProduceAsync(topic, new Message<string, string> { Key = key, Value = json });
  74. _logger.LogInformation($"成功发送消息 {dr.Key}.{ @event.Key}, offSet: {dr.TopicPartitionOffset}");
  75. } catch (ProduceException<string, string> ex) {
  76. _logger.LogError(ex, $"发送失败 {topic}.{key}.{ @event.Key}, 原因 {ex.Error.Reason} ");
  77. throw new ValidationException("当前服务器繁忙,请稍后再尝试");
  78. }
  79. }
  80.  
  81. /// <summary>
  82. /// 释放方法
  83. /// </summary>
  84. public void Dispose() {
  85. _producer?.Dispose();
  86. }
  87.  
  88. /// <summary>
  89. /// 要释放的对象
  90. /// </summary>
  91. public IProducer<string, string> Object { get; }
  92. }
  93. }

  在这里我们来看看IMessageProducer接口定义

  1. using System.Threading.Tasks;
  2. using Sunlight.Kafka.Abstractions;
  3.  
  4. namespace Sunlight.Kafka
  5. {
  6. /// <summary>
  7. /// 消息的生产者
  8. /// </summary>
  9. public interface IMessageProducer
  10. {
  11. /// <summary>
  12. /// 发送事件
  13. /// </summary>
  14. /// <param name="event"></param>
  15. void Produce(IIntegrationEvent @event);
  16.  
  17. /// <summary>
  18. /// 发送事件
  19. /// </summary>
  20. /// <param name="event"></param>
  21. Task ProduceAsync(IIntegrationEvent @event);
  22.  
  23. /// <summary>
  24. /// 发送事件
  25. /// </summary>
  26. /// <param name="event"></param>
  27. /// <param name="eventName">指定事件的名称</param>
  28. /// <returns></returns>
  29. Task ProduceAsync(IIntegrationEvent @event, string eventName);
  30. }
  31. }

  在接口中我们分别定义了消息发送的同步和异步及重载方法,另外我们还继承了ABP中的IDisposableDependencyObjectWrapper接口,关于这个接口我们来看一下接口的声明和定义(想了解更多的关于ABP的知识,也可点击这里关注本人之前的博客)。

  1. using System;
  2.  
  3. namespace Abp.Dependency
  4. {
  5. /// <summary>
  6. /// This interface is used to wrap an object that is resolved from IOC container.
  7. /// It inherits <see cref="IDisposable"/>, so resolved object can be easily released.
  8. /// In <see cref="IDisposable.Dispose"/> method, <see cref="IIocResolver.Release"/> is called to dispose the object.
  9. /// This is non-generic version of <see cref="IDisposableDependencyObjectWrapper{T}"/> interface.
  10. /// </summary>
  11. public interface IDisposableDependencyObjectWrapper : IDisposableDependencyObjectWrapper<object>
  12. {
  13.  
  14. }
  15. }

  如果想了解关于这个接口更多的信息,请点击这里

  另外在实际发送消息的时候,我们需要记录消息的具体Partition以及Offset这样我们就能够快速找到这条消息,从而方便后面的重试,另外有时候由于服务器的网络问题的时候可能抛出MessageTimeout的消息,这个时候我们需要通过Confluent.Kafka库中的ProduceException异常来捕获这些信息记录抛出异常信息,另外在我们的业务层需要给出一个“当前服务器繁忙,请稍后再尝试”这样一个友好的提示信息。

  另外在发送消息的时候,每一次都会产生一个Guid类型的Key发送到消息的消费方,这个Key将会作为接收消息的实体KafkaReceivedMessage 的主键Id,这个会在后文有具体的解释。

  二 消费者方

  在我们这篇文章记录的重点就是消费方,因为这里我们需要解决诸如消息重复消费以及乐观锁冲突的一系列问题,后面我们将会就这些问题来一一进行讲解和说明。

  2.1 如何解决消息重复消费

  在这里我们通过KafkaReceivedMessage这样一个实体来在数据库中记录收到的消息,并且在发送方每次发送时候传递唯一的一个Guid,这样我们就简单利用每次插入消息时主键Id不允许重复来处理重复发送的同一条消息的问题,我们首先来看看这个实体。

  1. /// <summary>
  2. /// Kafka消费者收到的消息记录
  3. /// </summary>
  4. public class KafkaReceivedMessage : Entity<Guid> {
  5. /// <summary>
  6. /// 消费者组
  7. /// </summary>
  8. [MaxLength(50)]
  9. [Required]
  10. public string Group { get; set; }
  11.  
  12. /// <summary>
  13. /// 消息主题
  14. /// </summary>
  15. [MaxLength(100)]
  16. [Required]
  17. public string Topic { get; set; }
  18.  
  19. /// <summary>
  20. /// 消息编号, 用于记录日志, 便于区分, 建议用编号
  21. /// </summary>
  22. [MaxLength(50)]
  23. public string Code { get; set; }
  24.  
  25. /// <summary>
  26. /// 消息内容
  27. /// </summary>
  28. [MaxLength(int.MaxValue)]
  29. public string Content { get; set; }
  30.  
  31. /// <summary>
  32. /// kafka 中的 partition
  33. /// </summary>
  34. public int? Partition { get; set; }
  35.  
  36. /// <summary>
  37. /// kafka 中的 offset
  38. /// </summary>
  39. [MaxLength(100)]
  40. [Required]
  41. public string Offset { get; set; }
  42.  
  43. /// <summary>
  44. /// 接受时间
  45. /// </summary>
  46. public DateTime ReceivedTime { get; set; }
  47.  
  48. /// <summary>
  49. /// 过期时间
  50. /// </summary>
  51. public DateTime? ExpiresAt { get; set; }
  52.  
  53. /// <summary>
  54. /// 重试次数
  55. /// </summary>
  56. public int Retries { get; set; }
  57.  
  58. /// <summary>
  59. /// 不是用Guid做全局唯一约束的消息
  60. /// </summary>
  61. public bool Old { get; set; }
  62.  
  63. /// <inheritdoc />
  64. public override string ToString() {
  65. return $"{Group}.{Topic}.{Id}.{Code},{Partition}:{Offset}";
  66. }

  有了这个实体,我们在接收到这条消息的时候我们首先会尝试将这条消息存入到数据库,如果存入成功就说明不是重复消息,如果存入失败,就记录Kafka收到重复消息,我们先来看一下具体的实现。

  1. using System;
  2. using System.ComponentModel.DataAnnotations;
  3. using System.Text;
  4. using System.Threading;
  5. using System.Threading.Tasks;
  6. using System.Data.SqlClient;
  7. using Abp.Domain.Uow;
  8. using Abp.Runtime.Validation;
  9. using Confluent.Kafka;
  10. using Microsoft.EntityFrameworkCore;
  11. using Microsoft.Extensions.Configuration;
  12. using Microsoft.Extensions.DependencyInjection;
  13. using Microsoft.Extensions.Hosting;
  14. using Microsoft.Extensions.Logging;
  15. using Newtonsoft.Json;
  16. using Sunlight.Kafka.Abstractions;
  17. using Sunlight.Kafka.Models;
  18.  
  19. namespace Sunlight.Kafka {
  20. /// <summary>
  21. /// Kafka 消费者的后台服务基础类
  22. /// </summary>
  23. /// <typeparam name="T">事件类型</typeparam>
  24. public abstract class KafkaConsumerHostedService<T> : BackgroundService where T : IIntegrationEvent {
  25. /// <summary>
  26. /// IOC服务提供方
  27. /// </summary>
  28. protected IServiceProvider Services { get; }
  29.  
  30. /// <summary>
  31. /// 配置文件
  32. /// </summary>
  33. protected IConfiguration Config { get; }
  34.  
  35. /// <summary>
  36. /// 主题
  37. /// </summary>
  38. protected string Topic { get; }
  39.  
  40. /// <summary>
  41. /// 日志
  42. /// </summary>
  43. protected ILogger<KafkaConsumerHostedService<T>> Logger { get; }
  44.  
  45. /// <summary>
  46. /// DbContext的类型, 必须是业务中实际的类型
  47. /// </summary>
  48. protected Type DbContextType { get; }
  49.  
  50. /// <summary>
  51. /// 消费者的配置
  52. /// </summary>
  53. protected ConsumerConfig ConsumerConfig { get; }
  54.  
  55. /// <summary>
  56. /// 保存失败时的重复次数, 一般用于 DbUpdateConcurrencyException
  57. /// </summary>
  58. protected int SaveDataRetries { get; }
  59.  
  60. /// <summary>
  61. /// 构造 <see cref="KafkaConsumerHostedService{T}"/>
  62. /// </summary>
  63. /// <param name="services"></param>
  64. /// <param name="config"></param>
  65. /// <param name="logger"></param>
  66. /// <param name="dbContext">DbContext的类型, 必须是业务中实际的类型</param>
  67. protected KafkaConsumerHostedService(IServiceProvider services,
  68. IConfiguration config,
  69. ILogger<KafkaConsumerHostedService<T>> logger, DbContext dbContext) {
  70. Services = services;
  71. Config = config;
  72. Logger = logger;
  73. DbContextType = dbContext.GetType();
  74.  
  75. Topic = Config.GetValue<string>($"Kafka:Topics:{typeof(T).Name}");
  76. if (string.IsNullOrWhiteSpace(Topic)) {
  77. Logger.LogCritical($"未能找到{typeof(T).Name}所对应的Topic");
  78. Environment.Exit(0);
  79. }
  80.  
  81. const int MaxRetries = 5;
  82. const int DefaultRetries = 2;
  83. SaveDataRetries = Config.GetValue<int?>("Kafka:SaveDataRetries") ?? DefaultRetries;
  84. SaveDataRetries = Math.Min(SaveDataRetries, MaxRetries);
  85.  
  86. ConsumerConfig = new ConsumerConfig {
  87. BootstrapServers = Config.GetValue<string>("Kafka:BootstrapServers"),
  88. AutoOffsetReset = AutoOffsetReset.Earliest,
  89. GroupId = Config.GetValue<string>("Application:Name"),
  90. EnableAutoCommit = true
  91. };
  92. }
  93.  
  94. /// <summary>
  95. /// 消费该事件,比如调用 Application Service 持久化数据等
  96. /// </summary>
  97. /// <param name="event">事件内容</param>
  98. protected abstract void DoWork(T @event);
  99.  
  100. /// <summary>
  101. /// 保存收到的消息到数据库, 防止重复消费
  102. /// </summary>
  103. /// <param name="message"></param>
  104. /// <returns></returns>
  105. private async Task<bool> SaveMessageAsync(KafkaReceivedMessage message) {
  106. using var scope = Services.CreateScope();
  107. var service = (DbContext)scope.ServiceProvider.GetRequiredService(DbContextType);
  108. service.Set<KafkaReceivedMessage>().Add(message);
  109. try {
  110. await service.SaveChangesAsync();
  111. Logger.LogInformation($"Kafka 收到消息 {message}");
  112. return true;
  113. } catch (DbUpdateException ex) when (ex.InnerException?.Message.Contains("PRIMARY KEY") == true) {
  114. Logger.LogError($"Kafka 收到重复消息 {message}");
  115. } finally {
  116. service.Entry(message).State = EntityState.Detached;
  117. }
  118. return false;
  119. }
  120.  
  121. /// <summary>
  122. /// 反序列化消息
  123. /// </summary>
  124. /// <param name="result"></param>
  125. /// <param name="message"></param>
  126. /// <returns></returns>
  127. protected virtual async Task<T> DeserializeEvent(ConsumeResult<string, string> result, KafkaReceivedMessage message) {
  128. T @event;
  129. try {
  130. @event = JsonConvert.DeserializeObject<T>(result.Value);
  131. } catch (Exception e) when(e is JsonReaderException || e is JsonSerializationException || e is JsonException) {
  132. @event = default;
  133. if (!await SaveMessageAsync(message))
  134. Logger.LogError(e, ErrorMessageTemp, message, e.InnerException?.Message ?? e.Message);
  135. }
  136.  
  137. if (Guid.TryParse(result.Key, out var key) && result.Key != @event?.Key) {
  138. message.Code = @event?.Key;
  139. message.Id = key;
  140. } else {
  141. message.Id = Guid.NewGuid();
  142. message.Code = result.Key;
  143. message.Old = true;
  144. }
  145.  
  146. return await SaveMessageAsync(message) ? @event : default;
  147. }
  148.  
  149. private async Task TryDoWork(T @event, KafkaReceivedMessage message, int saveRetries) {
  150. if (saveRetries <= 0) {
  151.  
  152. Logger.LogError(ErrorMessageTemp, message, "乐观锁冲突");
  153. return;
  154. }
  155.  
  156. try {
  157. DoWork(@event);
  158. // 在遇到 乐观锁冲突的时候, 需要重试几次, 因为这很容易就发生了.
  159. } catch (DbUpdateConcurrencyException) {
  160. #pragma warning disable SCS0005 // Weak random generator
  161.  
  162. // 这样在收到重复消息的时候, 能降低冲突的概率
  163. await Task.Delay(new Random(DateTime.Now.Millisecond).Next(10,100));
  164. await TryDoWork(@event, message, --saveRetries);
  165. } catch (AbpDbConcurrencyException) {
  166. await Task.Delay(new Random(DateTime.Now.Millisecond).Next(10,100));
  167. await TryDoWork(@event, message, --saveRetries);
  168. }
  169. #pragma warning restore SCS0005 // Weak random generator
  170.  
  171. }
  172.  
  173. const string ErrorMessageTemp = "Kafka 消息 {0} 消费失败, 原因: {1}";
  174.  
  175. /// <summary>
  176. /// 构造 Kafka 消费者实例,监听指定 Topic,获得最新的事件
  177. /// </summary>
  178. /// <param name="stoppingToken">终止标识</param>
  179. /// <returns></returns>
  180. protected override async Task ExecuteAsync(CancellationToken stoppingToken) {
  181. await Task.Factory.StartNew(async () => {
  182. var builder = new ConsumerBuilder<string, string>(ConsumerConfig);
  183. using var consumer = builder.Build();
  184. consumer.Subscribe(Topic);
  185. //当前事件的Key
  186. Logger.LogInformation($"Kafka 消费者订阅 {Topic}");
  187. while (!stoppingToken.IsCancellationRequested) {
  188. try {
  189. var result = consumer.Consume(stoppingToken);
  190. //包含分区和OffSet的详细信息
  191. var message = new KafkaReceivedMessage {
  192. Group = ConsumerConfig.GroupId,
  193. Topic = result.Topic,
  194. Content = result.Value,
  195. Partition = result.Partition,
  196. Offset = result.Offset.ToString(),
  197. ReceivedTime = DateTime.Now
  198. };
  199. try {
  200. var @event = await DeserializeEvent(result, message);
  201. if (@event == null)
  202. continue;
  203. TryDoWork(@event, message, SaveDataRetries);
  204. } catch (ValidationException ex) {
  205. Logger.LogError(ex, ErrorMessageTemp, message, ex.InnerException?.Message ?? ex.Message);
  206. } catch (AbpValidationException ex) {
  207. Logger.LogError(ex, ErrorMessageTemp, message, GetValidationErrorNarrative(ex));
  208. } catch (SqlException ex) {
  209. Logger.LogError(ex, ErrorMessageTemp, message, ex.InnerException?.Message ?? ex.Message);
  210. } catch (Exception ex) {
  211. Logger.LogError(ex, ErrorMessageTemp, message, ex.InnerException?.Message ?? ex.Message);
  212. }
  213. } catch (OperationCanceledException ex) {
  214. consumer.Close();
  215. Logger.LogInformation(ex, "Kafka 消费者结束,退出后台线程");
  216. } catch (ConsumeException ex) {
  217. Logger.LogError(ex, "Kafka 消费者产生异常,");
  218. } catch (KafkaException ex) {
  219. Logger.LogError(ex, "Kafka 产生异常,");
  220. }
  221. }
  222. }, stoppingToken, TaskCreationOptions.LongRunning, TaskScheduler.Default);
  223. }
  224.  
  225. private static string GetValidationErrorNarrative(AbpValidationException validationException) {
  226. var detailBuilder = new StringBuilder();
  227. detailBuilder.AppendLine("验证过程中检测到以下错误");
  228.  
  229. foreach (var validationResult in validationException.ValidationErrors) {
  230. detailBuilder.AppendFormat(" - {0}", validationResult.ErrorMessage);
  231. detailBuilder.AppendLine();
  232. }
  233.  
  234. return detailBuilder.ToString();
  235. }
  236. }
    }

  这里我们通过SaveMessageAsync这个异步方法来保存数据到数据库,检测的时候我们通过捕获InnerException里面的Message中是否包含"PRIMARY KEY"来判断是不是主键冲突的。

  3.2 乐观锁冲突校验

  在做了第一步消息重复消费校验后,我们需要利用数据库中的DbUpdateConcurrencyException来捕获乐观锁的冲突,因为我们的业务处理都是通过继承KafkaConsumerHostedService这个基类,然后重载里面的DoWork方法来实现对业务代码的调用的,当然由于Kafka消息的异步特性,所以不可避免多个消息同时修改同一个实体,而由于这些异步消息产生的DbUpdateConcurrencyException就不可避免,在这里我们采用的默认次数是2次,最多可以重试5次的机制,通过这种方式来保证乐观锁冲突,如果5次重试还是失败则会提示乐观锁冲突,并且日志记录当前错误内容,通过这种方式能够在一定程度上减少由于并发问题导致的消费者消费失败的概率,当然关于这方面的探索还在随着业务的不断深入而不断去优化,期待后续的持续关注。

  3.3 异常的捕获与处理

  在我们的接收到消息以后会产生各种异常,如果处理这些异常也是非常重要的,当然根据这些异常的级别分别记录不同级别的日志是非常重要的,这里仅选择一种AbpValidationException这一种特例来进行说明,如果你对ABP中的AbpValidationException还不是很熟悉的话,请先阅读这篇文章。  

  1. private static string GetValidationErrorNarrative(AbpValidationException validationException) {
  2. var detailBuilder = new StringBuilder();
  3. detailBuilder.AppendLine("验证过程中检测到以下错误");
  4.  
  5. foreach (var validationResult in validationException.ValidationErrors) {
  6. detailBuilder.AppendFormat(" - {0}", validationResult.ErrorMessage);
  7. detailBuilder.AppendLine();
  8. }
  9.  
  10. return detailBuilder.ToString();
  11. }

  由于在这里ABP中ValidationException中ValidationErrors会记录一组之前验证的错误信息,所以这里需要特别注意,这里在阅读的时候需要特别注意。

在Asp.Net Core中集成Kafka(中)的更多相关文章

  1. 在Asp.Net Core中集成Kafka

    在我们的业务中,我们通常需要在自己的业务子系统之间相互发送消息,一端去发送消息另一端去消费当前消息,这就涉及到使用消息队列MQ的一些内容,消息队列成熟的框架有多种,这里你可以读这篇文章来了解这些MQ的 ...

  2. 从ASP.Net Core Web Api模板中移除MVC Razor依赖项

    前言 :本篇文章,我将会介绍如何在不包括MVC / Razor功能和包的情况下,添加最少的依赖项到ASP.NET Core Web API项目中. 一.MVC   VS WebApi (1)在ASP. ...

  3. 在ASP.NET Core的startup类中如何使用MemoryCache

    问: 下面的代码,在ASP.NET Core的startup类中创建了一个MemoryCache并且存储了三个键值“entryA”,“entryB”,“entryC”,之后想在Controller中再 ...

  4. asp.net core mvc 集成miniprofiler

    原文:asp.net core mvc 集成miniprofiler asp.net core mvc 集成miniprofiler 一.环境介绍 二.监控asp.net 页面 三.监控执行的sql语 ...

  5. 跨平台应用集成(在ASP.NET Core MVC 应用程序中集成 Microsoft Graph)

    作者:陈希章 发表于 2017年6月25日 谈一谈.NET 的跨平台 终于要写到这一篇了.跨平台的支持可以说是 Office 365 平台在设计伊始就考虑的目标.我在前面的文章已经提到过了,Micro ...

  6. 如何在ASP.NET Core Web API测试中使用Postman

    使用Postman进行手动测试 如果您是开发人员,测试人员或管理人员,则在构建和使用应用程序时,有时了解各种API方法可能是一个挑战. 使用带有.NET Core的Postman为您的Web API生 ...

  7. 【Docker】Asp.net core在docker容器中的端口问题

    还记得[One by one系列]一步步学习docker(三)--实战部署dotnetcore中遇到的问题么?容器内部启动始终是80端口,并不由命令左右. docker run --name cont ...

  8. ASP.NET Core 在 JSON 文件中配置依赖注入

    前言 在上一篇文章中写了如何在MVC中配置全局路由前缀,今天给大家介绍一下如何在在 json 文件中配置依赖注入. 在以前的 ASP.NET 4+ (MVC,Web Api,Owin,SingalR等 ...

  9. VS 2017开发ASP.NET Core Web应用过程中发现的一个重大Bug

    今天试着用VS 2017去开发一个.net core项目,想着看看.net core的开发和MVC5开发有什么区别,然后从中发现了一个VS2017的Bug. 首先,我们新建项目,ASP.NET Cor ...

随机推荐

  1. SQLEXPR_x64_CHS、SQLEXPRADV_x64_CHS、SQLEXPRWT_x64_CHS、SqlLocalDB、SQLManagementStudio_x64_CHS各版本说明

    LocalDB (SqlLocalDB)LocalDB 是 Express的一种轻型版本,该版本具备所有可编程性功能,但在用户模式下运行,并且具有快速的零配置安装和必备组件要求较少的特点.如果您需要通 ...

  2. tiny web服务器源码分析

    tiny web服务器源码分析 正如csapp书中所记,在短短250行代码中,它结合了许多我们已经学习到的思想,如进程控制,unix I/O,套接字接口和HTTP.虽然它缺乏一个实际服务器所具备的功能 ...

  3. Qt Creater-特殊注释TODO,FIXME

    简述 TODO: + 说明: 如果代码中有该标识,说明在标识处有功能代码待编写,待实现的功能在说明中会简略说明. FIXME: + 说明: 如果代码中有该标识,说明标识处代码需要修正,甚至代码是错误的 ...

  4. gitlab 构建常见错误

    1.前端是http服务后端是https,原因生产https,测试是http服务环境.代理后端2. java 打包程序需要运行正式数据库没连上错误.打包和跑正式的一个库.3. jenkins不能直接no ...

  5. mac PHP安装imageMagic扩展

    1. 安装:ImageMagick:命令:brew install ImageMagick这种方式安装下来的imageMagic,不缺少东西,报错较少.安装之后的位置:/usr/local/Cella ...

  6. Flutter Wrap 组件实现流布局

    Wrap 可以实现流布局,单行的 Wrap 跟 Row 表现几乎一致,单列的 Wrap 则跟 Row 表 现几乎一致.但 Row 与 Column 都是单行单列的,Wrap 则突破了这个限制,main ...

  7. Mockplus更快更简单的原型设计

    更快更简单的原型设计 https://www.mockplus.cn/ Mockplus,更快更简单的原型设计工具.快速创建原型,一键拖拽创建交互,团队协作省事省力.微软.华为.东软.育碧.Oracl ...

  8. osgViewer

    /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield * * This library is open source ...

  9. 泡泡一分钟:Semi-Dense Visual-Inertial Odometry and Mapping for Quadrotors with SWAP Constraints

    张宁 Semi-Dense Visual-Inertial Odometry and Mapping for Quadrotors with SWAP Constraints 具有SWAP约束的四旋翼 ...

  10. 【html】window.open()被部分浏览器拦截问题

    一.原因:1.因为在chrome的安全机制里面,非用户触发的window.open方法,是会被拦截的: 二.什么情况下不会被拦截或会被拦截? 1. $('#btn').click(function ( ...