面向對象23種設計模式系列(三)- 行為型設計模式

来源:https://www.cnblogs.com/xyh9039/archive/2020/07/27/13340315.html
-Advertisement-
Play Games

本系列將和大家分享面向對象23種設計模式中常用的幾種設計模式,本章主要簡單介紹下行為型設計模式。 ...


行為型設計模式:關註對象和行為的分離。(共11個)

  甩鍋大法:把鍋丟出去,只管自己,哪管洪水滔天。把不穩定的地方移出去,自己只寫穩定的,能保證自身的穩定。

  沒有什麼設計模式是完美無缺的,一個設計模式就是解決一類的問題的,通常設計模式在解決一類問題的同時,還會帶來別的問題,我們設計者要做的事兒,就是要揚長避短,充分發揮長處!

  很多時候,可能會融合應用多個設計模式,分別解決對應的問題。

下麵我們結合幾種具體場景來分析幾種行為型設計模式。

1、模板方法模式(TemplateMethod Pattern)

模板方法設計模式在基類父類定義流程,把可變邏輯分離到不同子類實現

有個複雜的多步驟業務,定義一個父類(模板),模板負責完成流程,把步驟分解,固定不變的當前類--各不相同的子類--有的相同有的不同虛方法。

就是把部分行為做了分離。

好處:就是可以擴展,職責分明。

場景:銀行客戶端查詢餘額業務,它通常是包含幾個步驟,例如:第一是校驗用戶名和密碼,第二是查詢真實餘額,第三是計算利息,第四將最終信息展示給客戶。對於不同的客戶而言,這些步驟流程一般是固定不變的,但每一步的具體實現又有可能是不一樣的。比如普通客戶和VIP客戶計算利息的利率是不一樣的、活期和定期的利率也是不一樣的,又比如普通客戶和VIP客戶的信息是存在不同的資料庫而導致用戶名和密碼校驗的具體實現可能也是不同的。這時候就可以考慮使用模板方法設計模式了,在基類中定義流程,把可變邏輯分離到不同子類實現。

下麵我們來重點看下代碼:

 抽象銀行客戶端:

using System;

namespace TemplateMethodPattern
{
    /// <summary>
    /// 抽象銀行客戶端
    /// </summary>
    public abstract class AbstractClient
    {
        /// <summary>
        /// 查詢(模板方法)
        /// </summary>
        public void Query(int id, string name, string password)
        {
            if (this.CheckUser(id, password))
            {
                double balance = this.QueryBalance(id);
                double interest = this.CalculateInterest(balance);
                this.Show(name, balance, interest);
            }
            else
            {
                Console.WriteLine("賬戶密碼錯誤");
            }
        }

        /// <summary>
        /// 用戶名和密碼校驗
        /// </summary>
        public virtual bool CheckUser(int id, string password)
        {
            return DateTime.Now < DateTime.Now.AddDays(1);
        }

        /// <summary>
        /// 查詢真實餘額
        /// </summary>
        public virtual double QueryBalance(int id)
        {
            return new Random().Next(10000, 1000000);
        }

        /// <summary>
        /// 計算利息
        /// 活期/定期/VIP 利率不同
        /// </summary>
        public abstract double CalculateInterest(double balance);

        /// <summary>
        /// 信息展示
        /// 有些一樣,有些不一樣
        /// </summary>
        public virtual void Show(string name, double balance, double interest)
        {
            Console.WriteLine("尊敬的{0}客戶,你的賬戶餘額為:{1},利息為{2}",
                name, balance, interest);
        }
    }
}

活期用戶:

using System;

namespace TemplateMethodPattern
{
    /// <summary>
    /// 銀行客戶端(活期用戶)
    /// </summary>
    public class ClientCurrent: AbstractClient
    {
        /// <summary>
        /// 活期利率不同
        /// </summary>
        public override double CalculateInterest(double balance)
        {
            return balance * 0.001;
        }
    }
}

定期用戶:

using System;

namespace TemplateMethodPattern
{
    /// <summary>
    /// 銀行客戶端(定期用戶)
    /// </summary>
    public class ClientRegular: AbstractClient
    {
        /// <summary>
        /// 定期利率不同
        /// </summary>
        public override double CalculateInterest(double balance)
        {
            return balance * 0.003;
        }
    }
}

VIP用戶:

using System;

namespace TemplateMethodPattern
{
    /// <summary>
    /// 銀行客戶端(VIP)
    /// </summary>
    public class ClientVip : AbstractClient
    {
        /// <summary>
        /// 計算利息
        /// VIP利率不同
        /// </summary>
        public override double CalculateInterest(double balance)
        {
            return balance * 0.005;
        }

        /// <summary>
        /// VIP的Show不一樣
        /// </summary>
        public override void Show(string name, double balance, double interest)
        {
            Console.WriteLine("尊貴的{0} vip客戶,您的賬戶餘額為:{1},利息為{2}",
                name, balance, interest);
        }
    }
}

使用如下:

using System;

namespace TemplateMethodPattern
{
    /// <summary>
    /// 模板方法設計模式
    /// 
    /// 有個複雜的多步驟業務,定義一個父類(模板),模板負責完成流程,把步驟分解,固定不變的當前類--各不相同的子類--有的相同有的不同虛方法。
    /// 就是把部分行為做了分離。
    /// 好處:就是可以擴展,職責分明。
    /// 設計模式沒那麼神奇,只不過是把常用的東西跟場景結合,沉澱下來起個名字。
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                {
                    AbstractClient client = new ClientCurrent();
                    client.Query(101, "張三", "123456");
                }
                {
                    AbstractClient client = new ClientRegular();
                    client.Query(102, "李四", "000000");
                }
                {
                    AbstractClient client = new ClientVip();
                    client.Query(103, "王五", "251146");
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }
    }
}

運行結果:

2、觀察者模式(Observer Pattern)

觀察者模式:一個對象動作觸發多個對象的行為(動作),通過觀察者可以去掉對象的依賴,支持各種自定義和擴展。

主題(Subject)發生變化是導致觀察者(Observer)觸發動作的根本原因。觀察者是觀察主題的。

場景:貓(主題)叫了一聲,觸發了觀察者的一系列動作,例如:老鼠跑、狗吼、雞叫、孩子哭等等。

下麵我們來重點看下代碼:

首先我們來看下不是使用觀察者模式實現的普通方法

using System;
using System.Collections.Generic;

using ObserverPattern.Observer;

namespace ObserverPattern.Subject
{
    /// <summary>
    /// 一隻神奇的貓
    /// 
    /// 貓叫一聲之後觸發一系列動作
    /// 老鼠跑、狗吼、雞叫、孩子哭
    /// </summary>
    public class Cat
    {
        /// <summary>
        /// 貓Miao了一聲
        /// 
        /// 依賴太多,任何一個對象改動,都會導致Cat變化。
        /// 違背了單一職責,不僅自己miao,還要觸發各種動作,不穩定。
        /// 加一個/減一個/調整順序  Cat都得改
        /// Cat職責:
        ///     1、Miao  2、觸發一系列動作  這是需求
        ///     實現上,這裡多了一個,3、指定動作
        /// </summary>
        public void Miao()
        {
            Console.WriteLine("{0} Miao.....", this.GetType().Name);

            //依賴了
            new Mouse().Run(); //老鼠跑
            new Dog().Wang(); //狗吼
            new Chicken().Woo(); //雞叫
            new Baby().Cry(); //孩子哭
        }
    }
}

上面的這段代碼就很不穩定,依賴太多,任何一個對象改動,都會導致Cat變化。違背了單一職責,不僅自己miao,還要觸發各種動作,不穩定。加一個/減一個/調整順序  Cat都得改。

竟然Cat不穩定,那我們就可以考慮將這一堆對象甩出去,自己不寫讓別人傳遞。

接下來我們使用觀察者模式實現下:

首先定義一個介面,這個介面只是為了能夠使多個對象產生關係,方便保存和調用

using System;

namespace ObserverPattern
{
    /// <summary>
    /// 只是為了使多個對象產生關係,方便保存和調用
    /// 方法本身其實沒用
    /// </summary>
    public interface IObserver
    {
        void Action();
    }
}

讓我們的觀察者都去實現這個介面

using System;

namespace ObserverPattern.Observer
{
    /// <summary>
    /// 老鼠
    /// </summary>
    public class Mouse : IObserver
    {
        public void Action()
        {
            this.Run();
        }

        public void Run()
        {
            Console.WriteLine("{0} Run", this.GetType().Name);
        }
    }
}
using System;

namespace ObserverPattern.Observer
{
    /// <summary>
    ////// </summary>
    public class Dog : IObserver
    {
        public void Action()
        {
            this.Wang();
        }

        public void Wang()
        {
            Console.WriteLine("{0} Wang", this.GetType().Name);
        }
    }
}
using System;

namespace ObserverPattern.Observer
{
    /// <summary>
    ////// </summary>
    public class Chicken : IObserver
    {
        public void Action()
        {
            this.Woo();
        }

        public void Woo()
        {
            Console.WriteLine("{0} Woo", this.GetType().Name);
        }
    }
}
using System;

namespace ObserverPattern.Observer
{
    /// <summary>
    /// 小孩
    /// </summary>
    public class Baby : IObserver
    {
        public void Action()
        {
            this.Cry();
        }

        public void Cry()
        {
            Console.WriteLine("{0} Cry", this.GetType().Name);
        }
    }
}

我們的貓(主題)添加一個觀察者對象容器,讓外部去添加對象

using System;
using System.Collections.Generic;

namespace ObserverPattern.Subject
{
    /// <summary>
    /// 一隻神奇的貓
    /// 
    /// 貓叫一聲之後觸發一系列動作
    /// 老鼠跑、狗吼、雞叫、孩子哭
    /// </summary>
    public class Cat
    {
        /// <summary>
        /// 存放觀察者的容器
        /// </summary>
        private List<IObserver> _observerList = new List<IObserver>();

        /// <summary>
        /// 添加觀察者
        /// </summary>
        public void AddObserver(IObserver observer)
        {
            this._observerList.Add(observer);
        }

        /// <summary>
        /// 觀察者模式Miao
        /// </summary>
        public void MiaoObserver()
        {
            Console.WriteLine("{0} MiaoObserver.....", this.GetType().Name);
            if (this._observerList != null && this._observerList.Count > 0)
            {
                foreach (var item in this._observerList)
                {
                    item.Action();
                }
            }
        }
    }
}

使用如下:

using System;

using ObserverPattern.Observer;
using ObserverPattern.Subject;

namespace ObserverPattern
{
    /// <summary>
    /// 觀察者模式
    /// 對象和行為的分離
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                {
                    Console.WriteLine("***************Observer***************");
                    Cat cat = new Cat();
                    cat.AddObserver(new Mouse());
                    cat.AddObserver(new Chicken());
                    cat.AddObserver(new Baby());
                    cat.AddObserver(new Dog());
                    cat.AddObserver(new Mouse());
                    cat.MiaoObserver();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.ReadKey();
        }
    }
}

運行結果:

上面的這種是標準的觀察者模式,是使用面向對象的方式實現的。其實觀察者模式還有一種更優雅的寫法,就是使用事件來實現的。如下所示:

using System;

namespace ObserverPattern.Subject
{
    /// <summary>
    /// 一隻神奇的貓
    /// 
    /// 貓叫一聲之後觸發一系列動作
    /// 老鼠跑、狗吼、雞叫、孩子哭
    /// </summary>
    public class Cat
    {
        private event Action MiaoHandler;
        public void MiaoEvent()
        {
            Console.WriteLine("{0} MiaoEvent.....", this.GetType().Name);
            if (this.MiaoHandler != null)
            {
                foreach (Action item in this.MiaoHandler.GetInvocationList())
                {
                    item.Invoke();
                }
            }
        }
    }
}

3、責任鏈模式(ResponsibilityChain Pattern)

責任鏈模式:請求的處理流程,沿著鏈子順序執行,還允許鏈子擴展和訂製。被稱為行為型設計模式的巔峰之作。

Context(上下文環境):用來保存業務處理中的參數--中間結果--最終結果。是行為型設計模式常用的標配。

為什麼說Context是行為型設計模式常用的標配呢?因為行為型設計模式關註的是對象和行為的分離,而方法(行為)在處理過程中就需要一些參數並且有返回值,這些信息就存放在Context上下文環境中。

場景:就以我們的請假審批流程為例,我們都知道不同的角色能夠審批的假期時長是不一樣的,例如:直接上級(SM)有權批1天的假期,主管(Charge)有權批3天的假期,經理(Manager)有權批7天的假期,總監(Chief)有權批30天假期,而我們的董事長(CEO)有權批300天的假期。下麵我們通過代碼來看下如何實現這個審批的功能。

首先我們來看下可能會想到的解決思路:

using System;

namespace ResponsibilityChainPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            //請假申請
            ApplyContext context = new ApplyContext()
            {
                Id = 1001,
                Name = "隔壁老王",
                Hour = 60,
                Description = "有急事需要請假幾天",
                AuditResult = false,
                AuditRemark = ""
            };

            {
                AbstractAuditor sm = new SM()
                {
                    Name = "直接上級"
                };
                sm.Audit(context);
                if (!context.AuditResult)
                {
                    AbstractAuditor charge = new Charge()
                    {
                        Name = "主管"
                    };
                    charge.Audit(context);
                    if (!context.AuditResult)
                    {
                        AbstractAuditor manager = new Manager()
                        {
                            Name = "經理"
                        };
                        manager.Audit(context);
                        if (!context.AuditResult)
                        {
                            //找下一環節
                        }
                    }
                }

                if (context.AuditResult)
                {
                    Console.WriteLine(context.AuditRemark);
                }
                else
                {
                    Console.WriteLine("不幹了!");
                }
            }
        }
    }
}

其實上面的這段代碼我們只是按照面向對象的思路翻譯了一遍,完全沒有設計、沒有加工、沒有思考。這裡就有一個很大的弊端,比如:此處隔壁老王請假60小時,首先他去找直接上級請假,發現直接上級沒有批假許可權。然後他又去找主管請假,發現主管也沒有批假許可權。接著他又要去找經理、找總監請假,如此找下去直到找到有批假許可權人員為止,這就很不符合常理。正確的思路應該是這樣的,隔壁老王直接將請假申請交給直接上級審批,對於直接上級來說,如果是許可權範圍內則審批通過,如果許可權範圍外則轉交下一環節審批。下一環節的審批人員也是如此。最終我們就可以將請求的處理流程,沿著鏈子順序執行。

接下來我們使用責任鏈模式來實現下這個功能:

請假申請上下文:

using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 請假申請
    /// Context(上下文環境):用來保存業務處理中的參數--中間結果--最終結果。是行為型設計模式常用的標配。
    /// 把行為轉移
    /// </summary>
    public class ApplyContext
    {
        public int Id { get; set; }

        /// <summary>
        /// 姓名
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// 請假時長
        /// </summary>
        public int Hour { get; set; }

        /// <summary>
        /// 請假理由
        /// </summary>
        public string Description { get; set; }

        /// <summary>
        /// 審核結果
        /// </summary>
        public bool AuditResult { get; set; }

        /// <summary>
        /// 審核備註
        /// </summary>
        public string AuditRemark { get; set; }
    }
}

抽象審核人員:

using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 抽象審核人員
    /// </summary>
    public abstract class AbstractAuditor
    {
        public string Name { get; set; }

        /// <summary>
        /// 審核
        /// </summary>
        public abstract void Audit(ApplyContext context);

        /// <summary>
        /// 下一個審核者
        /// </summary>
        private AbstractAuditor _nextAuditor = null;

        /// <summary>
        /// 指定下一個審核者
        /// </summary>
        public void SetNext(AbstractAuditor auditor)
        {
            this._nextAuditor = auditor;
        }

        /// <summary>
        /// 交給下一個審核人員審核
        /// </summary>
        protected void AuditNext(ApplyContext context)
        {
            if (this._nextAuditor != null)
            {
                this._nextAuditor.Audit(context);
            }
            else
            {
                context.AuditResult = false;
                context.AuditRemark = "不允許請假!";
            }
        }
    }
}

下麵我們不同角色的審核人員都去繼承抽象的審核人員,審核職責是:許可權範圍內則審批通過,許可權範圍外則轉交下一環節審批。

using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 直接上級
    /// 
    /// 職責問題:
    ///     1、許可權範圍內,審批通過。
    ///     2、許可權範圍外,轉交下一環節審批。
    /// </summary>
    public class SM : AbstractAuditor
    {
        public override void Audit(ApplyContext context)
        {
            Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
            if (context.Hour <= 8)
            {
                context.AuditResult = true;
                context.AuditRemark = "允許請假!";
            }
            else
            {
                base.AuditNext(context); //轉交下一環節審批
            }
        }
    }
}
using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 主管
    /// </summary>
    public class Charge : AbstractAuditor
    {
        public override void Audit(ApplyContext context)
        {
            Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
            if (context.Hour <= 24)
            {
                context.AuditResult = true;
                context.AuditRemark = "允許請假!";
            }
            else
            {
                base.AuditNext(context); //轉交下一環節審批
            }
        }
    }
}
using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 經理
    /// </summary>
    public class Manager : AbstractAuditor
    {
        public override void Audit(ApplyContext context)
        {
            Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
            if (context.Hour <= 56)
            {
                context.AuditResult = true;
                context.AuditRemark = "允許請假!";
            }
            else
            {
                base.AuditNext(context); //轉交下一環節審批
            }
        }
    }
}
using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 總監
    /// </summary>
    public class Chief : AbstractAuditor
    {
        public override void Audit(ApplyContext context)
        {
            Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
            if (context.Hour <= 240)
            {
                context.AuditResult = true;
                context.AuditRemark = "允許請假!";
            }
            else
            {
                base.AuditNext(context); //轉交下一環節審批
            }
        }
    }
}
using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 董事長
    /// </summary>
    public class CEO : AbstractAuditor
    {
        public override void Audit(ApplyContext context)
        {
            Console.WriteLine($"This is {this.GetType().Name} {this.Name} Audit");
            if (context.Hour <= 2400)
            {
                context.AuditResult = true;
                context.AuditRemark = "允許請假!";
            }
            else
            {
                base.AuditNext(context); //轉交下一環節審批
            }
        }
    }
}

最後來看下如何使用:

using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 建造者
    /// </summary>
    public class AuditorBuilder
    {
        public static AbstractAuditor Build()
        {
            AbstractAuditor sm = new SM()
            {
                Name = "直接上級"
            };
            AbstractAuditor charge = new Charge()
            {
                Name = "主管"
            };
            AbstractAuditor manager = new Manager()
            {
                Name = "經理"
            };
            AbstractAuditor chief = new Chief()
            {
                Name = "總監"
            };
            AbstractAuditor ceo = new CEO()
            {
                Name = "董事長"
            };

            //轉交下一環節,允許鏈子擴展和訂製
            sm.SetNext(charge);
            charge.SetNext(manager);
            manager.SetNext(chief);
            chief.SetNext(ceo);
            return sm;
        }
    }
}
using System;

namespace ResponsibilityChainPattern
{
    /// <summary>
    /// 責任鏈模式:請求的處理流程,沿著鏈子順序執行,還允許鏈子擴展和訂製。被稱為行為型設計模式的巔峰之作。
    /// </summary>
    class Program
    {
        static void Main(	   

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

-Advertisement-
Play Games
更多相關文章
  • 代碼片段: org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean if (!mbd.isSynthetic() && hasInstantiationAwareBeanPos ...
  • 屬性掃描完成之後, 就可以開始屬性註入了. 代碼塊: org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean boolean earlySingletonExposure = ...
  • 創建完對象之後, 接下來, 就應該想辦法對屬性進行註入了, 其中就包括 @Autowired 註入 但是在註入之前, 貌似 還沒有對 @Autowired 進行掃描和解析. 代碼塊: if (instanceWrapper == null) { /** * 創建 bean 實例,並將實例包裹在 Be ...
  • 點此獲取下載地址提取碼:y9u5 Python網路編程最好新手入門書籍!175個詳細案例,事實勝於雄辯,Sockets、DNS、Web Service、FTP、Email、SMTP、POP、IMAP、SocketServe、CGI、XML、Forking、資料庫查詢手機客戶端、多核、非同步通信……詳細 ...
  • spring在創建對象(org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance)的時候, 使用了這個 構造函數後置處理器, 用來選擇使用哪個構造函數的. 所以這個後 ...
  • 接著前面, 看完構造函數前的後置處理器, 就到 doCreateBean 方法了. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] ...
  • 又是好久沒有寫題解了。。。。。 1.題意分析: P2299是一道非常經典的圖論最短路練習題。 圖論最短路是圖論中非常重要的一個知識模塊,其主要演算法有Dijkstra,Bellman-Ford,SPFA和Floyd。在這片題解中我們著重介紹Dijkstra演算法。 2.演算法詳解: Dijkstra應該是 ...
  • 一、Servlet 1. 什麼是Servlet Servlet 是 JavaEE 規範之一,規範就是介面 Servlet 就 JavaWeb 三大組件之一,三大組件分別是:Servlet 程式、Filter 過濾器、Listener 監聽器 Servlet 是運行在伺服器上的一個 java 小程式, ...
一周排行
    -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版本說明 機器同時安裝了 ...