(七)分散式通信----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
更多相關文章
  • 1.Collection List 有序,可重覆,可以操作下標 | ArrayList: | LinkedList:Node(數據,地址) | Vector Set 無序,不可重覆,不可以操作下標 | HashSet:哈希表(根據哈希值確定對象的存儲位置) | add() int hashCode( ...
  • Python 入門之流程式控制制語句 if判斷 while迴圈 for迴圈 ...
  • 立刻像專業人士一樣構建API 組織正在改變他們已經在軟體應用項目中成功的微服務架構模型,這就是大多數微服務項目使用 (應用程式介面)的原因。 我們要為微服務喝彩,因為它相對於其他的模型有各種先進的特性。 與此類似,這些數據存儲區具有獨立的命令來處理每個數據存儲區;此外,它還允許軟體提供商更快地部署組 ...
  • 今天開始批量執行用例~,場景是這樣的: 工作中我們可能有多個模塊文件(.py)這些文件根據不同的業務類型或功能,測試案例分佈在不同的模塊文件下。前面的小示例中,我們的測試用例都是在一個文件中,直接運行的測試套件~,開發階段或者調試階段這樣做是沒毛病的,但是如果是測試運行階段,我們不可能這個模塊文件下 ...
  • 要談列表的複製,我們就要談到Python的賦值規則 首先我們創建列表a: 通常我們複製一個元素的方法是這樣的: 通過這行代碼,我們固然是創建了一個與列表a相等的列表b,但此時卻會出現一個問題: 當我們嘗試對新創建的列表b進行排序操作(如倒序操作)時: 到這裡一切看似沒啥毛病,實則坑爹的事情已經悄然發 ...
  • Lombok是一款好用順手的工具,就像Google Guava一樣,在此予以強烈推薦,每一個Java工程師都應該使用它。Lombok是一種Java™實用工具,可用來幫助開發人員消除Java的冗長代碼,尤其是對於簡單的Java對象(POJO)。它通過註釋實現這一目的。通過在開發環境中實現Lombok,... ...
  • 一、構造函數 構造函數是類的特殊方法,它永遠不會返回值(即使是void),並且方法名和類名相同,同樣支持重載。在使用new關鍵字創建對象時構造函數被間接調用,為對象初始化欄位和屬性的值。 無參構造函數即預設構造函數,在我們沒有創建任何構造函數時,編譯器會為我們創建一個預設構造函數,反之當我們創建了任 ...
  • 使用Settings sync同步VS Code配置 因為要在多臺電腦上使用VSCode,想要簡單地管理VSCode地配置,不用每次手動去一一配置,保持多個開發環境的同步,於是使用Settings sync插件來實現這個需求。 第一步:在VS Code中安裝Settings sync插件 第二步:在 ...
一周排行
    -Advertisement-
    Play Games
  • Timer是什麼 Timer 是一種用於創建定期粒度行為的機制。 與標準的 .NET System.Threading.Timer 類相似,Orleans 的 Timer 允許在一段時間後執行特定的操作,或者在特定的時間間隔內重覆執行操作。 它在分散式系統中具有重要作用,特別是在處理需要周期性執行的 ...
  • 前言 相信很多做WPF開發的小伙伴都遇到過表格類的需求,雖然現有的Grid控制項也能實現,但是使用起來的體驗感並不好,比如要實現一個Excel中的表格效果,估計你能想到的第一個方法就是套Border控制項,用這種方法你需要控制每個Border的邊框,並且在一堆Bordr中找到Grid.Row,Grid. ...
  • .NET C#程式啟動閃退,目錄導致的問題 這是第2次踩這個坑了,很小的編程細節,容易忽略,所以寫個博客,分享給大家。 1.第一次坑:是windows 系統把程式運行成服務,找不到配置文件,原因是以服務運行它的工作目錄是在C:\Windows\System32 2.本次坑:WPF桌面程式通過註冊表設 ...
  • 在分散式系統中,數據的持久化是至關重要的一環。 Orleans 7 引入了強大的持久化功能,使得在分散式環境下管理數據變得更加輕鬆和可靠。 本文將介紹什麼是 Orleans 7 的持久化,如何設置它以及相應的代碼示例。 什麼是 Orleans 7 的持久化? Orleans 7 的持久化是指將 Or ...
  • 前言 .NET Feature Management 是一個用於管理應用程式功能的庫,它可以幫助開發人員在應用程式中輕鬆地添加、移除和管理功能。使用 Feature Management,開發人員可以根據不同用戶、環境或其他條件來動態地控制應用程式中的功能。這使得開發人員可以更靈活地管理應用程式的功 ...
  • 在 WPF 應用程式中,拖放操作是實現用戶交互的重要組成部分。通過拖放操作,用戶可以輕鬆地將數據從一個位置移動到另一個位置,或者將控制項從一個容器移動到另一個容器。然而,WPF 中預設的拖放操作可能並不是那麼好用。為瞭解決這個問題,我們可以自定義一個 Panel 來實現更簡單的拖拽操作。 自定義 Pa ...
  • 在實際使用中,由於涉及到不同編程語言之間互相調用,導致C++ 中的OpenCV與C#中的OpenCvSharp 圖像數據在不同編程語言之間難以有效傳遞。在本文中我們將結合OpenCvSharp源碼實現原理,探究兩種數據之間的通信方式。 ...
  • 一、前言 這是一篇搭建許可權管理系統的系列文章。 隨著網路的發展,信息安全對應任何企業來說都越發的重要,而本系列文章將和大家一起一步一步搭建一個全新的許可權管理系統。 說明:由於搭建一個全新的項目過於繁瑣,所有作者將挑選核心代碼和核心思路進行分享。 二、技術選擇 三、開始設計 1、自主搭建vue前端和. ...
  • Csharper中的表達式樹 這節課來瞭解一下表示式樹是什麼? 在C#中,表達式樹是一種數據結構,它可以表示一些代碼塊,如Lambda表達式或查詢表達式。表達式樹使你能夠查看和操作數據,就像你可以查看和操作代碼一樣。它們通常用於創建動態查詢和解析表達式。 一、認識表達式樹 為什麼要這樣說?它和委托有 ...
  • 在使用Django等框架來操作MySQL時,實際上底層還是通過Python來操作的,首先需要安裝一個驅動程式,在Python3中,驅動程式有多種選擇,比如有pymysql以及mysqlclient等。使用pip命令安裝mysqlclient失敗應如何解決? 安裝的python版本說明 機器同時安裝了 ...