（七）分散式通信----Netty實現NIO通信

来源:https://www.cnblogs.com/hongwei918/archive/2019/08/25/11302181.html
-Advertisement-
Play Games

項目文件結構圖 1. 消息監聽器（黃色框） 這部分由 Netty 實現，Netty是一個非同步且非阻塞的通信框架。TCP通信實現服務端和客戶端的交互。 Netty 的簡單描述如下： 客戶端（調用方）：負責發送要執行的指令。 服務端（接收方）：分為主從線程。主線程負責接收指令，將指令存入緩存區中，等待執 ...


項目文件結構圖

 

1. 消息監聽器（黃色框）

這部分由 Netty 實現，Netty是一個非同步且非阻塞的通信框架。TCP通信實現服務端和客戶端的交互。

Netty 的簡單描述如下：

客戶端（調用方）：負責發送要執行的指令。

服務端（接收方）：分為主從線程。主線程負責接收指令，將指令存入緩存區中，等待執行完成後再通知客戶端（非阻塞）；

　　　　　　　　　　　　　　　　從線程，有不止一個線程（非同步），負責從緩存池中取出線程依次執行（按隊列先後順序執行），我們通過程式來決定先執行哪個，比如先解碼，後執行，再編碼。

 

2. 指令執行器（紅色框）

上圖中只有服務端的實現，服務端接收到指令後會回調執行器中的過程。

客戶端的時候需要在業務場景中來實現，根據業務不同，接收到服務端消息後執行的過程也不同。然後通過控制反轉，由程式自動找到該過程。

 

3. 消息發送器（藍色框）

將要發送的消息寫入到通信管道中，服務端和客戶端都有實現。

 

4. 客戶端工廠（綠色框）

為啥沒有服務端工廠呢，因為服務端是由服務端主機（Host）直接創建的，主機直接調用監聽器監聽埠。既然我們重寫了通信過程，就不能用微軟原有的WebHost，後續會講到如何搭建自己的主機。

客戶端工廠用來創建客戶端，然後與服務端主機通信。

 

5. 序列化工具（白色框）

上節中我們用MessagePack實現了序列化與反序列化，本節為通信，自然離不開消息序列化。

 

 

1. 消息監聽器（黃色框）

上層介面：

    /// <summary>
    /// 接受到消息的委托。
    /// </summary>
    /// <param name="sender">消息發送者。</param>
    /// <param name="message">接收到的消息。</param>
    public delegate Task ReceivedDelegate(IMessageSender sender, TransportMessage message);

    /// <summary>
    /// 一個抽象的消息監聽者。
    /// </summary>
    public interface IMessageListener
    {
        /// <summary>
        /// 接收到消息的事件。
        /// </summary>
        event ReceivedDelegate Received;

        /// <summary>
        /// 觸發接收到消息事件。
        /// </summary>
        /// <param name="sender">消息發送者。</param>
        /// <param name="message">接收到的消息。</param>
        /// <returns>一個任務。</returns>
        Task OnReceived(IMessageSender sender, TransportMessage message);
    }

 

客戶端：

/// <summary>
    /// 消息監聽者。
    /// </summary>
    public class DotNettyClientMessageListener : IMessageListener
    {
        #region Implementation of IMessageListener

        /// <summary>
        /// 接收到消息的事件。
        /// </summary>
        public event ReceivedDelegate Received;

        /// <summary>
        /// 觸發接收到消息事件。
        /// </summary>
        /// <param name="sender">消息發送者。</param>
        /// <param name="message">接收到的消息。</param>
        /// <returns>一個任務。</returns>
        public async Task OnReceived(IMessageSender sender, TransportMessage message)
        {
            if (Received == null)
                return;
            await Received(sender, message);
        }

        #endregion Implementation of IMessageListener
    }

 

服務端：

    public class DotNettyServerMessageListener : IMessageListener, IDisposable
    {
        #region Field

        private readonly ILogger<DotNettyServerMessageListener> _logger;
        private readonly ITransportMessageDecoder _transportMessageDecoder;
        private readonly ITransportMessageEncoder _transportMessageEncoder;
        private IChannel _channel;

        #endregion Field

        #region Constructor

        public DotNettyServerMessageListener(ILogger<DotNettyServerMessageListener> logger, ITransportMessageCodecFactory codecFactory)
        {
            _logger = logger;
            _transportMessageEncoder = codecFactory.GetEncoder();
            _transportMessageDecoder = codecFactory.GetDecoder();
        }

        #endregion Constructor

        #region Implementation of IMessageListener

        public event ReceivedDelegate Received;

        /// <summary>
        /// 觸發接收到消息事件。
        /// </summary>
        /// <param name="sender">消息發送者。</param>
        /// <param name="message">接收到的消息。</param>
        /// <returns>一個任務。</returns>
        public async Task OnReceived(IMessageSender sender, TransportMessage message)
        {
            if (Received == null)
                return;
            await Received(sender, message);
        }

        #endregion Implementation of IMessageListener

        public async Task StartAsync(EndPoint endPoint)
        {
            if (_logger.IsEnabled(LogLevel.Debug))
                _logger.LogDebug($"準備啟動服務主機，監聽地址：{endPoint}。");

            IEventLoopGroup bossGroup = new MultithreadEventLoopGroup(1);
            IEventLoopGroup workerGroup = new MultithreadEventLoopGroup();//Default eventLoopCount is Environment.ProcessorCount * 2
            var bootstrap = new ServerBootstrap();
            bootstrap
            .Channel<TcpServerSocketChannel>()
            .Option(ChannelOption.SoBacklog, 128)
            .ChildOption(ChannelOption.Allocator, PooledByteBufferAllocator.Default)
            .Group(bossGroup, workerGroup)
            .ChildHandler(new ActionChannelInitializer<IChannel>(channel =>
            {
                var pipeline = channel.Pipeline;
                pipeline.AddLast(new LengthFieldPrepender(4));
                pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4));
                pipeline.AddLast(new TransportMessageChannelHandlerAdapter(_transportMessageDecoder));
                pipeline.AddLast(new ServerHandler(async (contenxt, message) =>
                {
                    var sender = new DotNettyServerMessageSender(_transportMessageEncoder, contenxt);
                    await OnReceived(sender, message);
                }, _logger));
            }));
            try
            {
                _channel = await bootstrap.BindAsync(endPoint);
                if (_logger.IsEnabled(LogLevel.Debug))
                    _logger.LogDebug($"服務主機啟動成功，監聽地址：{endPoint}。");
            }
            catch
            {
                _logger.LogError($"服務主機啟動失敗，監聽地址：{endPoint}。 ");
            }
        }

        public void CloseAsync()
        {
            Task.Run(async () =>
            {
                await _channel.EventLoop.ShutdownGracefullyAsync();
                await _channel.CloseAsync();
            }).Wait();
        }

        #region Implementation of IDisposable

        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
        public void Dispose()
        {
            Task.Run(async () =>
            {
                await _channel.DisconnectAsync();
            }).Wait();
        }

        #endregion Implementation of IDisposable

        #region Help Class

        private class ServerHandler : ChannelHandlerAdapter
        {
            private readonly Action<IChannelHandlerContext, TransportMessage> _readAction;
            private readonly ILogger _logger;

            public ServerHandler(Action<IChannelHandlerContext, TransportMessage> readAction, ILogger logger)
            {
                _readAction = readAction;
                _logger = logger;
            }

            #region Overrides of ChannelHandlerAdapter

            public override void ChannelRead(IChannelHandlerContext context, object message)
            {
                Task.Run(() =>
                {
                    var transportMessage = (TransportMessage)message;
                    _readAction(context, transportMessage);
                });
            }

            public override void ChannelReadComplete(IChannelHandlerContext context)
            {
                context.Flush();
            }

            public override void ExceptionCaught(IChannelHandlerContext context, Exception exception)
            {
                context.CloseAsync();//客戶端主動斷開需要應答，否則socket變成CLOSE_WAIT狀態導致socket資源耗盡
                if (_logger.IsEnabled(LogLevel.Error))
                    _logger.LogError(null,exception, $"與伺服器：{context.Channel.RemoteAddress}通信時發送了錯誤。");
            }

            #endregion Overrides of ChannelHandlerAdapter
        }

        #endregion Help Class
    }

 

2. 指令執行器（紅色框）

上層介面：

    /// <summary>
    /// 一個抽象的服務執行器。
    /// </summary>
    public interface IServiceExecutor
    {
        /// <summary>
        /// 執行。
        /// </summary>
        /// <param name="sender">消息發送者。</param>
        /// <param name="message">調用消息。</param>
        Task ExecuteAsync(IMessageSender sender, TransportMessage message);
    }

 

實現類，代碼中沒有處理邏輯（服務發現、執行，後續有專題來談），只有輸出列印 "服務提供者接收到消息。" ：

    public class HttpServiceExecutor : IServiceExecutor
    {
        #region Field
        
        private readonly ILogger<HttpServiceExecutor> _logger;
        #endregion Field

        #region Constructor

        public HttpServiceExecutor(ILogger<HttpServiceExecutor> logger)
        {
            _logger = logger;
        }

        #endregion Constructor

        #region Implementation of IServiceExecutor

        /// <summary>
        /// 執行。
        /// </summary>
        /// <param name="sender">消息發送者。</param>
        /// <param name="message">調用消息。</param>
        public async Task ExecuteAsync(IMessageSender sender, TransportMessage message)
        {
            if (_logger.IsEnabled(LogLevel.Trace))
                _logger.LogTrace("服務提供者接收到消息。");
            return;

        }
        #endregion Implementation of IServiceExecutor
    }

 

3. 消息發送器（藍色框）

上層介面：

    /// <summary>
    /// 一個抽象的發送者。
    /// </summary>
    public interface IMessageSender
    {
        /// <summary>
        /// 發送消息。
        /// </summary>
        /// <param name="message">消息內容。</param>
        /// <returns>一個任務。</returns>
        Task SendAsync(TransportMessage message);

        /// <summary>
        /// 發送消息並清空緩衝區。
        /// </summary>
        /// <param name="message">消息內容。</param>
        /// <returns>一個任務。</returns>
        Task SendAndFlushAsync(TransportMessage message);
    }

 

實現類基類：

    /// <summary>
    /// 基於DotNetty的消息發送者基類。
    /// </summary>
    public abstract class DotNettyMessageSender
    {
        private readonly ITransportMessageEncoder _transportMessageEncoder;

        protected DotNettyMessageSender(ITransportMessageEncoder transportMessageEncoder)
        {
            _transportMessageEncoder = transportMessageEncoder;
        }

        protected IByteBuffer GetByteBuffer(TransportMessage message)
        {
            var data = _transportMessageEncoder.Encode(message);
            //var buffer = PooledByteBufferAllocator.Default.Buffer();
            return Unpooled.WrappedBuffer(data);
        }
    }

服務端：

    /// <summary>
    /// 基於DotNetty服務端的消息發送者。
    /// </summary>
    public class DotNettyServerMessageSender : DotNettyMessageSender, IMessageSender
    {
        private readonly IChannelHandlerContext _context;

        public DotNettyServerMessageSender(ITransportMessageEncoder transportMessageEncoder, IChannelHandlerContext context) : base(transportMessageEncoder)
        {
            _context = context;
        }

        #region Implementation of IMessageSender

        /// <summary>
        /// 發送消息。
        /// </summary>
        /// <param name="message">消息內容。</param>
        /// <returns>一個任務。</returns>
        public async Task SendAsync(TransportMessage message)
        {
            var buffer = GetByteBuffer(message);
            await _context.WriteAsync(buffer);
        }

        /// <summary>
        /// 發送消息並清空緩衝區。
        /// </summary>
        /// <param name="message">消息內容。</param>
        /// <returns>一個任務。</returns>
        public async Task SendAndFlushAsync(TransportMessage message)
        {
            var buffer = GetByteBuffer(message);
            await _context.WriteAndFlushAsync(buffer);
        }

        #endregion Implementation of IMessageSender
    }

客戶端：

/// <summary>
    /// 基於DotNetty客戶端的消息發送者。
    /// </summary>
    public class DotNettyMessageClientSender : DotNettyMessageSender, IMessageSender, IDisposable
    {
        private readonly IChannel _channel;

        public DotNettyMessageClientSender(ITransportMessageEncoder transportMessageEncoder, IChannel channel) : base(transportMessageEncoder)
        {
            _channel = channel;
        }

        #region Implementation of IDisposable

        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
        public void Dispose()
        {
            Task.Run(async () =>
            {
                await _channel.DisconnectAsync();
            }).Wait();
        }

        #endregion Implementation of IDisposable

        #region Implementation of IMessageSender

        /// <summary>
        /// 發送消息。
        /// </summary>
        /// <param name="message">消息內容。</param>
        /// <returns>一個任務。</returns>
        public async Task SendAsync(TransportMessage message)
        {
            var buffer = GetByteBuffer(message);
            await _channel.WriteAndFlushAsync(buffer);
        }

        /// <summary>
        /// 發送消息並清空緩衝區。
        /// </summary>
        /// <param name="message">消息內容。</param>
        /// <returns>一個任務。</returns>
        public async Task SendAndFlushAsync(TransportMessage message)
        {
            var buffer = GetByteBuffer(message);
            await _channel.WriteAndFlushAsync(buffer);
        }

        #endregion Implementation of IMessageSender
    }

 

4. 客戶端工廠（綠色框）

上層介面：

    /// <summary>
    /// 一個抽象的傳輸客戶端工廠。
    /// </summary>
    public interface ITransportClientFactory
    {
        /// <summary>
        /// 創建客戶端。
        /// </summary>
        /// <param name="endPoint">終結點。</param>
        /// <returns>傳輸客戶端實例。</returns>
        Task<ITransportClient> CreateClientAsync(EndPoint endPoint);
    }

 

    /// <summary>
    /// 一個抽象的傳輸客戶端。
    /// </summary>
    public interface ITransportClient
    {
        /// <summary>
        /// 發送消息。
        /// </summary>
        /// <param name="message">遠程調用消息模型。</param>
        /// <returns>遠程調用消息的傳輸消息。</returns>
        Task SendAsync(TransportMessage transportMessage);
    }

 

實現類：

    /// <summary>
    /// 基於DotNetty的傳輸客戶端工廠。
    /// </summary>
    public class DotNettyTransportClientFactory : ITransportClientFactory, IDisposable
    {
        #region Field

        private readonly ITransportMessageEncoder _transportMessageEncoder;
        private readonly ITransportMessageDecoder _transportMessageDecoder;
        private readonly ILogger<DotNettyTransportClientFactory> _logger;
        private readonly IServiceExecutor _serviceExecutor;
        private readonly ConcurrentDictionary<EndPoint, Lazy<Task<ITransportClient>>> _clients = new ConcurrentDictionary<EndPoint, Lazy<Task<ITransportClient>>>();
        private readonly Bootstrap _bootstrap;

        private static readonly AttributeKey<IMessageSender> messageSenderKey = AttributeKey<IMessageSender>.ValueOf(typeof(DotNettyTransportClientFactory), nameof(IMessageSender));
        private static readonly AttributeKey<IMessageListener> messageListenerKey = AttributeKey<IMessageListener>.ValueOf(typeof(DotNettyTransportClientFactory), nameof(IMessageListener));
        private static readonly AttributeKey<EndPoint> origEndPointKey = AttributeKey<EndPoint>.ValueOf(typeof(DotNettyTransportClientFactory), nameof(EndPoint));

        #endregion Field

        #region Constructor

        public DotNettyTransportClientFactory(ITransportMessageCodecFactory codecFactory, ILogger<DotNettyTransportClientFactory> logger)
            : this(codecFactory,  logger, null)
        {
        }

        public DotNettyTransportClientFactory(ITransportMessageCodecFactory codecFactory, ILogger<DotNettyTransportClientFactory> logger, IServiceExecutor serviceExecutor)
        {
            _transportMessageEncoder = codecFactory.GetEncoder();
            _transportMessageDecoder = codecFactory.GetDecoder();
            _logger = logger;
            _serviceExecutor = serviceExecutor;
            _bootstrap = GetBootstrap();
            _bootstrap.Handler(new ActionChannelInitializer<ISocketChannel>(c =>
            {
                var pipeline = c.Pipeline;
                pipeline.AddLast(new LengthFieldPrepender(4));
                pipeline.AddLast(new LengthFieldBasedFrameDecoder(int.MaxValue, 0, 4, 0, 4));
                pipeline.AddLast(new TransportMessageChannelHandlerAdapter(_transportMessageDecoder));
                pipeline.AddLast(new DefaultChannelHandler(this));
            }));
        }

        #endregion Constructor

        #region Implementation of ITransportClientFactory

        /// <summary>
        /// 創建客戶端。
        /// </summary>
        /// <param name="endPoint">終結點。</param>
        /// <returns>傳輸客戶端實例。</returns>
        public async Task<ITransportClient> CreateClientAsync(EndPoint endPoint)
        {
            var key = endPoint;
            if (_logger.IsEnabled(LogLevel.Debug))
                _logger.LogDebug($"準備為服務端地址：{key}創建客戶端。");
            try
            {
                return await _clients.GetOrAdd(key
                    , k => new Lazy<Task<ITransportClient>>(async () =>
                    {
                        //客戶端對象
                        var bootstrap = _bootstrap;
                        //非同步連接返回channel
                        var channel = await bootstrap.ConnectAsync(k);
                        var messageListener = new DotNettyClientMessageListener();
                        //設置監聽
                        channel.GetAttribute(messageListenerKey).Set(messageListener);
                        //實例化發送者
                        var messageSender = new DotNettyMessageClientSender(_transportMessageEncoder, channel);
                        //設置channel屬性
                        channel.GetAttribute(messageSenderKey).Set(messageSender);
                        channel.GetAttribute(origEndPointKey).Set(k);
                        //創建客戶端
                        var client = new DotNettyTransportClient(messageSender, messageListener, _logger, _serviceExecutor);
                        return client;
                    }
                    )).Value;//返回實例
            }
            catch
            {
                throw;
            }
        }

        #endregion Implementation of ITransportClientFactory

        #region Implementation of IDisposable

        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
        public void Dispose()
        {
            foreach (var client in _clients.Values.Where(i => i.IsValueCreated))
            {
                (client.Value as IDisposable)?.Dispose();
            }
        }

        #endregion Implementation of IDisposable

        private static Bootstrap GetBootstrap()
        {
            IEventLoopGroup group;

            var bootstrap = new Bootstrap();

            group = new MultithreadEventLoopGroup();
            bootstrap.Channel<TcpServerSocketChannel>();
            
            bootstrap
                .Channel<TcpSocketChannel>()
                .Option(ChannelOption.TcpNodelay, true)
                .Option(ChannelOption.Allocator, PooledByteBufferAllocator.Default)
                .Group(group);

            return bootstrap;
        }

        protected class DefaultChannelHandler : ChannelHandlerAdapter
        {
            private readonly DotNettyTransportClientFactory _factory;

            public DefaultChannelHandler(DotNettyTransportClientFactory factory)
            {
                this._factory = factory;
            }

            #region Overrides of ChannelHandlerAdapter

            public override void ChannelInactive(IChannelHandlerContext context)
            {
                _factory._clients.TryRemove(context.Channel.GetAttribute(origEndPointKey).Get(), out var value);
            }

            public override void ChannelRead(IChannelHandlerContext context, object message)
            {
                var transportMessage = message as TransportMessage;

                var messageListener = context.Channel.GetAttribute(messageListenerKey).Get();
                var messageSender = context.Channel.GetAttribute(messageSenderKey).Get();
                messageListener.OnReceived(messageSender, transportMessage);
            }

            #endregion Overrides of ChannelHandlerAdapter
        }
    }

 

    /// <summary>
    /// 一個預設的傳輸客戶端實現。
    /// </summary>
    public class DotNettyTransportClient : ITransportClient, IDisposable
    {
        #region Field

        private readonly IMessageSender _messageSender;
        private readonly IMessageListener _messageListener;
        private readonly ILogger _logger;
        private readonly IServiceExecutor _serviceExecutor;

        #endregion Field

        #region Constructor

        public DotNettyTransportClient(IMessageSender messageSender, IMessageListener messageListener, ILogger logger, IServiceExecutor serviceExecutor)
        {
            _messageSender = messageSender;
            _messageListener = messageListener;
            _logger = logger;
            _serviceExecutor = serviceExecutor;
            messageListener.Received += MessageListener_Received;
        }

        #endregion Constructor

        #region Implementation of ITransportClient

        /// <summary>
        /// 發送消息。
        /// </summary>
        /// <param name="message">遠程調用消息模型。</param>
        /// <returns>遠程調用消息的傳輸消息。</returns>
        public async Task SendAsync(TransportMessage transportMessage)
        {
            try
            {
                if (_logger.IsEnabled(LogLevel.Debug))
                    _logger.LogDebug("準備發送消息。");

                try
                {
                    //發送
                    await _messageSender.SendAndFlushAsync(transportMessage);
                }
                catch (Exception exception)
                {
                    throw new Exception("與服務端通訊時發生了異常。", exception);
                }

                if (_logger.IsEnabled(LogLevel.Debug))
                    _logger.LogDebug("消息發送成功。");
                
            }
            catch (Exception exception)
            {
                if (_logger.IsEnabled(LogLevel.Error))
                    _logger.LogError(null,exception, "消息發送失敗。");
                throw;
            }
        }

        #endregion Implementation of ITransportClient

        #region Implementation of IDisposable

        /// <summary>Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.</summary>
        public void Dispose()
        {
            (_messageSender as IDisposable)?.Dispose();
            (_messageListener as IDisposable)?.Dispose();
        }

        #endregion Implementation of IDisposable

        #region Private Method

        private async Task MessageListener_Received(IMessageSender sender, TransportMessage message)
        {
            if (_logger.IsEnabled(LogLevel.Trace))
                _logger.LogTrace("服務消費者接收到消息。");
            
            if (_serviceExecutor != null)
                await _serviceExecutor.ExecuteAsync(sender, message);
        }

        #endregion Private Method
    }

 

5. 序列化工具（白色框）

需要繼承自 DotNetty.Transport.Channels.ChannelHandlerAdapter，才能被 netty 調用：

public class TransportMessageChannelHandlerAdapter : ChannelHandlerAdapter
    {
        private readonly ITransportMessageDecoder _transportMessageDecoder;

        public TransportMessageChannelHandlerAdapter(ITransportMessageDecoder transportMessageDecoder)
        {
            _transportMessageDecoder = transportMessageDecoder;
        }

        #region Overrides of ChannelHandlerAdapter

        public override void ChannelRead(IChannelHandlerContext context, object message)
        {
            var buffer = (IByteBuffer)message;
            var data = new byte[buffer.ReadableBytes];
            buffer.ReadBytes(data);
            var transportMessage = _transportMessageDecoder.Decode(data);
            context.FireChannelRead(transportMessage);
            ReferenceCountUtil.Release(buffer);
        }

        #endregion Overrides of ChannelHandlerAdapter
    }

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Java學習第十四天
    1.Collection List 有序，可重覆，可以操作下標 | ArrayList： | LinkedList：Node(數據，地址) | Vector Set 無序，不可重覆，不可以操作下標 | HashSet：哈希表（根據哈希值確定對象的存儲位置） | add() int hashCode( ...
  • Python 入門之流程式控制制語句
    Python 入門之流程式控制制語句 if判斷 while迴圈 for迴圈 ...
  • Top11 構建和測試API的工具
    立刻像專業人士一樣構建API 組織正在改變他們已經在軟體應用項目中成功的微服務架構模型，這就是大多數微服務項目使用 （應用程式介面）的原因。 我們要為微服務喝彩，因為它相對於其他的模型有各種先進的特性。 與此類似，這些數據存儲區具有獨立的命令來處理每個數據存儲區；此外，它還允許軟體提供商更快地部署組 ...
  • python+unittest框架第四天unittest之批量執行案例
    今天開始批量執行用例~，場景是這樣的: 工作中我們可能有多個模塊文件（.py）這些文件根據不同的業務類型或功能，測試案例分佈在不同的模塊文件下。前面的小示例中，我們的測試用例都是在一個文件中，直接運行的測試套件~，開發階段或者調試階段這樣做是沒毛病的，但是如果是測試運行階段，我們不可能這個模塊文件下 ...
  • Python學習之路：關於列表（List）複製的那點事
    要談列表的複製，我們就要談到Python的賦值規則 首先我們創建列表a： 通常我們複製一個元素的方法是這樣的： 通過這行代碼，我們固然是創建了一個與列表a相等的列表b，但此時卻會出現一個問題： 當我們嘗試對新創建的列表b進行排序操作（如倒序操作）時： 到這裡一切看似沒啥毛病，實則坑爹的事情已經悄然發 ...
  • 十分鐘搞懂Lombok使用與原理
    Lombok是一款好用順手的工具，就像Google Guava一樣，在此予以強烈推薦，每一個Java工程師都應該使用它。Lombok是一種Java™實用工具，可用來幫助開發人員消除Java的冗長代碼，尤其是對於簡單的Java對象（POJO）。它通過註釋實現這一目的。通過在開發環境中實現Lombok，... ...
  • C#類型成員：構造函數
    一、構造函數 構造函數是類的特殊方法，它永遠不會返回值（即使是void）,並且方法名和類名相同，同樣支持重載。在使用new關鍵字創建對象時構造函數被間接調用，為對象初始化欄位和屬性的值。 無參構造函數即預設構造函數，在我們沒有創建任何構造函數時，編譯器會為我們創建一個預設構造函數，反之當我們創建了任 ...
  • 使用Settings sync同步VS Code配置
    使用Settings sync同步VS Code配置 因為要在多臺電腦上使用VSCode，想要簡單地管理VSCode地配置，不用每次手動去一一配置，保持多個開發環境的同步，於是使用Settings sync插件來實現這個需求。 第一步：在VS Code中安裝Settings sync插件 第二步：在 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類