Cats（2）－ Free語法組合，Coproduct-ADT composition

来源:http://www.cnblogs.com/tiger-xc/archive/2016/09/08/5851763.html
-Advertisement-
Play Games

上篇我們介紹了Free類型可以作為一種嵌入式編程語言DSL在函數式編程中對某種特定功能需求進行描述。一個完整的應用可能會涉及多樣的關聯功能，但如果我們為每個應用都設計一套DSL的話，那麼在我們的函數式編程中將會不斷重覆的功能相似的DSL。我們應該秉承函數式編程的核心思想：函數組合（compositi ...


    上篇我們介紹了Free類型可以作為一種嵌入式編程語言DSL在函數式編程中對某種特定功能需求進行描述。一個完整的應用可能會涉及多樣的關聯功能，但如果我們為每個應用都設計一套DSL的話，那麼在我們的函數式編程中將會不斷重覆的功能相似的DSL。我們應該秉承函數式編程的核心思想：函數組合（compositionality）來實現DSL的組合：把DSL拆解成最基礎語句ADT，然後用這些ADT來組合成適合應用功能要求的完整DSL。我們還是使用上篇那個Interact DSL，這次再增加一個Login功能：

 1 package demo.app
 2 import cats.free.{Free,Inject}
 3 object FreeModules {
 4   object ADTs {
 5     sealed trait Interact[+A]
 6     object Interact {
 7       case class Ask(prompt: String) extends Interact[String]
 8       case class Tell(msg: String) extends Interact[Unit]
 9       type FreeInteract[A] = Free[Interact,A]
10       def ask(prompt: String): FreeInteract[String] = Free.liftF(Ask(prompt))
11       def tell(msg: String): FreeInteract[Unit] = Free.liftF(Tell(msg))
12     }
13 
14     sealed trait Login[+A]
15     object Login {
16       type FreeLogin[A] = Free[Login,A]
17       case class Authenticate(user: String, pswd: String) extends Login[Boolean]
18       def authenticate(user: String, pswd: String): FreeLogin[Boolean] =
19         Free.liftF(Authenticate(user,pswd))
20     }
21 
22   }
23 
24 }

上面我們增加了個Login類。我們先來進行DSL編程：

 1   object DSLs {
 2     import ADTs._
 3     import Interact._
 4     import Login._
 5     val interactDSL: FreeInteract[Unit]  = for {
 6       first <- ask("What's your first name?")
 7       last <- ask("What's your last name?")
 8       _ <- tell(s"Hello, $first $last!")
 9     } yield()
10 
11     val loginDSL: FreeLogin[Boolean] = for {
12       login <- authenticate("Tiger","123")
13     } yield login
14   }

很明顯，用一種DSL編程是無法滿足Login功能需要的。我們需要像下麵這樣的DSL：

1  val interactLoginDSL: Free[???,Boolean] = for {
2       uid <- ask("Enter your User ID:")
3       psw <- ask("Enter your Password:")
4       aut <- authenticate(uid,pwd)
5     } yield aut

不過上面的???應該是什麼呢？它應該是Interact和Login的集合。cats提供了Coproduct，它是一個樹形數據結構：

/** `F` on the left and `G` on the right of [[scala.util.Either]].
 *
 * @param run The underlying [[scala.util.Either]].
 */
final case class Coproduct[F[_], G[_], A](run: Either[F[A], G[A]]) {...}

Coproduct 的每一個節點（Either[F[A],G[A]]）都是一個ADT，F[A]或者G[A]。我們可以用多層遞歸Coproduce結構來構建一個多語法的樹形結構，如：

1 type H[A] = Coproduct[F,G,A]
2 type I[A] = Coproduct[H,X,A]
3 type J[A] = Coproduct[J,Y,A]  //ADT(F,G,X,Y)

用Coproduct的樹形結構可以容納多種DSL的ADT。在上面的例子里我們需要一個組合的語法InteractLogin：

1 type InteractLogin[A] = Coproduct[Interact,Login,A]

cats提供了Inject類來構建Coproduct：

sealed abstract class Inject[F[_], G[_]] {
  def inj[A](fa: F[A]): G[A]

  def prj[A](ga: G[A]): Option[F[A]]
}

private[free] sealed abstract class InjectInstances {
  implicit def catsFreeReflexiveInjectInstance[F[_]]: Inject[F, F] =
    new Inject[F, F] {
      def inj[A](fa: F[A]): F[A] = fa

      def prj[A](ga: F[A]): Option[F[A]] = Some(ga)
    }

  implicit def catsFreeLeftInjectInstance[F[_], G[_]]: Inject[F, Coproduct[F, G, ?]] =
    new Inject[F, Coproduct[F, G, ?]] {
      def inj[A](fa: F[A]): Coproduct[F, G, A] = Coproduct.leftc(fa)

      def prj[A](ga: Coproduct[F, G, A]): Option[F[A]] = ga.run.fold(Some(_), _ => None)
    }

  implicit def catsFreeRightInjectInstance[F[_], G[_], H[_]](implicit I: Inject[F, G]): Inject[F, Coproduct[H, G, ?]] =
    new Inject[F, Coproduct[H, G, ?]] {
      def inj[A](fa: F[A]): Coproduct[H, G, A] = Coproduct.rightc(I.inj(fa))

      def prj[A](ga: Coproduct[H, G, A]): Option[F[A]] = ga.run.fold(_ => None, I.prj)
    }
}

inj[A](fa: F[A]):G[A]代表將F[A]註入更大的語法集G[A]。cats提供了三種實現了ink函數的Inject隱式實例：

1、catsFreeReflexiveInjectInstance:Inject[F,F]：對單一語法，無須構建Coproduct

2、catsFreeLeftInjectInstance:Inject[F,Coproduct[F,G,?]]：構建Coproduct結構並將F放在左邊

3、catsFreeRightInjectInstance:Inject[F,Coproduct[H,G,?]]：把F註入到已經包含H,G的Coproduct[H,G,?]

有了這三種實例後我們可以根據解析到的隱式實例類型使用inj函數通過Coproduct構建更大的語法集了。我們可以通過implicitly來驗證一下Interact和Login語法的Inject隱式實例：

1     val selfInj = implicitly[Inject[Interact,Interact]]
2     type LeftInterLogin[A] = Coproduct[Interact,Login,A]
3     val leftInj = implicitly[Inject[Interact,LeftInterLogin]]
4     type RightInterLogin[A] = Coproduct[Login,LeftInterLogin,A]
5     val rightInj = implicitly[Inject[Interact,RightInterLogin]]

現在我們可以用Inject.inj和Free.liftF把Interact和Login升格成Free[G,A]。G是個類型變數，Interact和Login在Coproduct的最終左右位置由當前Inject隱式實例類型決定：

 1   object ADTs {
 2     sealed trait Interact[+A]
 3     object Interact {
 4       case class Ask(prompt: String) extends Interact[String]
 5       case class Tell(msg: String) extends Interact[Unit]
 6       type FreeInteract[A] = Free[Interact,A]
 7       //def ask(prompt: String): FreeInteract[String] = Free.liftF(Ask(prompt))
 8       //def tell(msg: String): FreeInteract[Unit] = Free.liftF(Tell(msg))
 9       def ask[G[_]](prompt: String)(implicit I: Inject[Interact,G]): Free[G,String] =
10         Free.liftF(I.inj(Ask(prompt)))
11       def tell[G[_]](msg: String)(implicit I: Inject[Interact,G]): Free[G,Unit] =
12         Free.liftF(I.inj(Tell(msg)))
13     }
14 
15     sealed trait Login[+A]
16     object Login {
17       type FreeLogin[A] = Free[Login,A]
18       case class Authenticate(user: String, pswd: String) extends Login[Boolean]
19       //def authenticate(user: String, pswd: String): FreeLogin[Boolean] =
20       //  Free.liftF(Authenticate(user,pswd))
21       def authenticate[G[_]](user: String, pswd: String)(implicit I: Inject[Login,G]): Free[G,Boolean] =
22         Free.liftF(I.inj(Authenticate(user,pswd)))
23     }

現在我們可以用混合語法的DSL來編程了：

 1   object DSLs {
 2     import ADTs._
 3     import Interact._
 4     import Login._
 5     val interactDSL: FreeInteract[Unit] = for {
 6       first <- ask("What's your first name?")
 7       last <- ask("What's your last name?")
 8       _ <- tell(s"Hello, $first $last!")
 9     } yield()
10 
11     val loginDSL: FreeLogin[Boolean] = for {
12       login <- authenticate("Tiger","123")
13     } yield login
14 
15     type InteractLogin[A] = Coproduct[Interact,Login,A]
16     val interactLoginDSL: Free[InteractLogin,Boolean] = for {
17       uid <- ask[InteractLogin]("Enter your User ID:")
18       pwd <- ask[InteractLogin]("Enter your Password:")
19       aut <- authenticate[InteractLogin](uid,pwd)
20     } yield aut
21   }

在interactLoginDSL里所有ADT通過Inject隱式實例都被自動升格成統一的Free[Coproduct[Interact,Login,A]]。

interactLogin的功能實現方式之一示範如下：

 1   object IMPLs {
 2     import cats.{Id,~>}
 3     import ADTs._,Interact._,Login._
 4     import DSLs._
 5     object InteractConsole extends (Interact ~> Id) {
 6       def apply[A](ia: Interact[A]): Id[A] = ia match {
 7         case Ask(p) => {println(p); readLine}
 8         case Tell(m) => println(m)
 9       }
10     }
11     object LoginMock extends (Login ~> Id) {
12       def apply[A](la: Login[A]): Id[A] = la match {
13         case Authenticate(u,p) => if (u == "Tiger" && p == "123") true else false
14       }
15     }
16     val interactLoginMock: (InteractLogin ~> Id) = InteractConsole.or(LoginMock)
17   }

這個interactLoginMock就是一個Interact,Login混合語法程式的功能實現。不過我們還是應該賦予Login一個比較實在點的實現：我們可以用一種依賴註入方式通過Reader數據類型把外部系統的用戶密碼驗證的方法傳入：

 1   import Dependencies._
 2     import cats.data.Reader
 3     type ReaderPass[A] = Reader[PasswordControl,A]
 4     object LoginToReader extends (Login ~> ReaderPass) {
 5       def apply[A](la: Login[A]): ReaderPass[A] = la match {
 6         case Authenticate(u,p) => Reader{pc => pc.matchUserPassword(u,p)}
 7       }
 8     }
 9     object InteractToReader extends (Interact ~> ReaderPass) {
10       def apply[A](ia: Interact[A]): ReaderPass[A] = ia match {
11         case Ask(p) => {println(p); Reader(pc => readLine)}
12         case Tell(m) => {println(m); Reader(pc => ())}
13       }
14     }
15     val userLogin: (InteractLogin ~> ReaderPass) = InteractToReader or LoginToReader

假設用戶密碼驗證由外部另一個系統負責，PasswordControl是與這個外部系統的界面（interface）：

1 object Dependencies {
2   trait PasswordControl {
3     val mapPasswords: Map[String,String]
4     def matchUserPassword(uid: String, pwd: String): Boolean
5   }
6 }

我們用Reader來註入PasswordControl這個外部依賴（dependency injection IOC）。因為Interact和Login結合形成的是一個統一的語句集，所以我們必須進行Interact與ReaderPass對應。下麵我們先構建一個PasswordControl對象作為模擬數據，然後試運行：

 1 object catsComposeFree extends App {
 2   import Dependencies._
 3   import FreeModules._
 4   import DSLs._
 5   import IMPLs._
 6   object UserPasswords extends PasswordControl {
 7     override val mapPasswords: Map[String, String] = Map(
 8       "Tiger" -> "123",
 9       "John" -> "456"
10     )
11     override def matchUserPassword(uid: String, pwd: String): Boolean =
12       mapPasswords.getOrElse(uid,pwd+"!") == pwd
13   }
14 
15   val r = interactLoginDSL.foldMap(userLogin).run(UserPasswords)
16   println(r)
17 
18 }

運算結果：

 1 Enter your User ID:
 2 Tiger
 3 Enter your Password:
 4 123
 5 true
 6 ...
 7 Enter your User ID:
 8 Chan
 9 Enter your Password:
10 123
11 false

我們再用這個混合的DSL編個稍微完整點的程式：

1     val userLoginDSL: Free[InteractLogin,Unit] = for {
2       uid <- ask[InteractLogin]("Enter your User ID:")
3       pwd <- ask[InteractLogin]("Enter your Password:")
4       aut <- authenticate[InteractLogin](uid,pwd)
5       _ <- if (aut) tell[InteractLogin](s"Hello $uid")
6            else tell[InteractLogin]("Sorry, who are you?")
7     } yield()

運算這個程式不需要任何修改：

1   //val r = interactLoginDSL.foldMap(userLogin).run(UserPasswords)
2   //println(r)
3   userLoginDSL.foldMap(userLogin).run(UserPasswords)

現在結果變成了：

 1 Enter your User ID:
 2 Tiger
 3 Enter your Password:
 4 123
 5 Hello Tiger
 6 ...
 7 Enter your User ID:
 8 CHAN
 9 Enter your Password:
10 123
11 Sorry, who are you?

如果我們在這兩個語法的基礎上再增加一個模擬許可權管理的語法，ADT設計如下：

1     sealed trait Auth[+A]
2     object Auth {
3       case class Authorize(uid: String) extends Auth[Boolean]
4       def authorize[G[_]](uid:String)(implicit I: Inject[Auth,G]): Free[G,Boolean] =
5         Free.liftF(I.inj(Authorize(uid)))
6     }

假設實際的許可權管理依賴外部系統，我們先定義它的界面：

 1 object Dependencies {
 2   trait PasswordControl {
 3     val mapPasswords: Map[String,String]
 4     def matchUserPassword(uid: String, pwd: String): Boolean
 5   }
 6   trait PermControl {
 7     val mapAuthorized: Map[String,Boolean]
 8     def authorized(uid: String): Boolean
 9   }
10 }

再用三種語法合成的DSL來編一段程式：

 1     import Auth._
 2     type Permit[A] = Coproduct[Auth,InteractLogin,A]
 3     val userPermitDSL: Free[Permit,Unit] = for {
 4       uid <- ask[Permit]("Enter your User ID:")
 5       pwd <- ask[Permit]("Enter your Password:")
 6       auth <- authenticate[Permit](uid,pwd)
 7       perm <- if(auth) authorize[Permit](uid)
 8               else Free.pure[Permit,Boolean](false)
 9       _ <- if (perm) tell[Permit](s"Hello $uid, welcome to the program!")
10            else tell[Permit]("Sorry, no no no!")
11     } yield()

很遺憾，這段代碼無法通過編譯，cats還無法處理多層遞歸Coproduct。對Coproduct的處理scalaz還是比較成熟的，我在之前寫過一篇scalaz Coproduct Free的博客，裡面用的例子就是三種語法的DSL。實際上不單隻是Coproduct的問題，現在看來cats.Free對即使很簡單的應用功能也有著很複雜無聊的代碼需求，這是我們無法接受的。由於Free編程在函數式編程里占據著如此重要的位置，我們暫時還沒有其它選擇，所以必須尋找一個更好的編程工具才行，freeK就是個這樣的函數組件庫。我們將在下篇討論里用freeK來實現多種語法DSL編程。

無論如何，我還是把這篇討論的示範代碼附在下麵：

 

  1 import cats.data.Coproduct
  2 import cats.free.{Free, Inject}
  3 object FreeModules {
  4   object ADTs {
  5     sealed trait Interact[+A]
  6     object Interact {
  7       case class Ask(prompt: String) extends Interact[String]
  8       case class Tell(msg: String) extends Interact[Unit]
  9       type FreeInteract[A] = Free[Interact,A]
 10       //def ask(prompt: String): FreeInteract[String] = Free.liftF(Ask(prompt))
 11       //def tell(msg: String): FreeInteract[Unit] = Free.liftF(Tell(msg))
 12       def ask[G[_]](prompt: String)(implicit I: Inject[Interact,G]): Free[G,String] =
 13         Free.liftF(I.inj(Ask(prompt)))
 14       def tell[G[_]](msg: String)(implicit I: Inject[Interact,G]): Free[G,Unit] =
 15         Free.liftF(I.inj(Tell(msg)))
 16     }
 17 
 18     sealed trait Login[+A]
 19     object Login {
 20       type FreeLogin[A] = Free[Login,A]
 21       case class Authenticate(user: String, pswd: String) extends Login[Boolean]
 22       //def authenticate(user: String, pswd: String): FreeLogin[Boolean] =
 23       //  Free.liftF(Authenticate(user,pswd))
 24       def authenticate[G[_]](user: String, pswd: String)(implicit I: Inject[Login,G]): Free[G,Boolean] =
 25         Free.liftF(I.inj(Authenticate(user,pswd)))
 26     }
 27 
 28     sealed trait Auth[+A]
 29     object Auth {
 30       case class Authorize(uid: String) extends Auth[Boolean]
 31       def authorize[G[_]](uid:String)(implicit I: Inject[Auth,G]): Free[G,Boolean] =
 32         Free.liftF(I.inj(Authorize(uid)))
 33     }
 34     val selfInj = implicitly[Inject[Interact,Interact]]
 35     type LeftInterLogin[A] = Coproduct[Interact,Login,A]
 36     val leftInj = implicitly[Inject[Interact,LeftInterLogin]]
 37     type RightInterLogin[A] = Coproduct[Login,LeftInterLogin,A]
 38     val rightInj = implicitly[Inject[Interact,RightInterLogin]]
 39   }
 40 
 41   object DSLs {
 42     import ADTs._
 43     import Interact._
 44     import Login._
 45     val interactDSL: FreeInteract[Unit] = for {
 46       first <- ask("What's your first name?")
 47       last <- ask("What's your last name?")
 48       _ <- tell(s"Hello, $first $last!")
 49     } yield()
 50 
 51     val loginDSL: FreeLogin[Boolean] = for {
 52       login <- authenticate("Tiger","123")
 53     } yield login
 54 
 55     type InteractLogin[A] = Coproduct[Interact,Login,A]
 56     val interactLoginDSL: Free[InteractLogin,Boolean] = for {
 57       uid <- ask[InteractLogin]("Enter your User ID:")
 58       pwd <- ask[InteractLogin]("Enter your Password:")
 59       aut <- authenticate[InteractLogin](uid,pwd)
 60     } yield aut
 61     val userLoginDSL: Free[InteractLogin,Unit] = for {
 62       uid <- ask[InteractLogin]("Enter your User ID:")
 63       pwd <- ask[InteractLogin]("Enter your Password:")
 64       aut <- authenticate[InteractLogin](uid,pwd)
 65       _ <- if (aut) tell[InteractLogin](s"Hello $uid")
 66            else tell[InteractLogin]("Sorry, who are you?")
 67     } yield()
 68   /*  import Auth._
 69     type Permit[A] = Coproduct[Auth,InteractLogin,A]
 70     val userPermitDSL: Free[Permit,Unit] = for {
 71       uid <- ask[Permit]("Enter your User ID:")
 72       pwd <- ask[Permit]("Enter your Password:")
 73       auth <- authenticate[Permit](uid,pwd)
 74       perm <- if(auth) authorize[Permit](uid)
 75               else Free.pure[Permit,Boolean](false)
 76       _ <- if (perm) tell[Permit](s"Hello $uid, welcome to the program!")
 77            else tell[Permit]("Sorry, no no no!")
 78     } yield() */
 79   }
 80   object IMPLs {
 81     import cats.{Id,~>}
 82     import ADTs._,Interact._,Login._
 83     import DSLs._
 84     object InteractConsole extends (Interact ~> Id) {
 85       def apply[A](ia: Interact[A]): Id[A] = ia match {
 86         case Ask(p) => {println(p); readLine}
 87         case Tell(m) => println(m)
 88       }
 89     }
 90     object LoginMock extends (Login ~> Id) {
 91       def apply[A](la: Login[A]): Id[A] = la match {
 92         case Authenticate(u,p) => if (u == "Tiger" && p == "123") true else false
 93       }
 94     }
 95     val interactLoginMock: (InteractLogin ~> Id) = InteractConsole.or(LoginMock)
 96     import Dependencies._
 97     import cats.data.Reader
 98     type ReaderPass[A] = Reader[PasswordControl,A]
 99     object LoginToReader extends (Login ~> ReaderPass) {
100       def apply[A](la: Login[A]): ReaderPass[A] = la match {
101         case Authenticate(u,p) => Reader{pc => pc.matchUserPassword(u,p)}
102       }
103     }
104     object InteractToReader extends (Interact ~> ReaderPass) {
105       def apply[A](ia: Interact[A]): ReaderPass[A] = ia match {
106         case Ask(p) => {println(p); Reader(pc => readLine)}
107         case Tell(m) => {println(m); Reader(pc => ())}
108       }
109     }
110     val userLogin: (InteractLogin ~> ReaderPass) = InteractToReader or LoginToReader
111 
112   }
113 }
114 object Dependencies {
115   trait PasswordControl {
116     val mapPasswords: Map[String,String]
117     def matchUserPassword(uid: String, pwd: String): Boolean
118   }
119   trait PermControl {
120     val mapAuthorized: Map[String,Boolean]
121     def authorized(uid: String): Boolean
122   }
123 }
124 
125 object catsComposeFree extends App {
126   import Dependencies._
127   import FreeModules._
128   import DSLs._
129   import IMPLs._
130   object UserPasswords extends PasswordControl {
131     override val mapPasswords: Map[String, String] = Map(
132       "Tiger" -> "123",
133       "John" -> "456"
134     )
135     override def matchUserPassword(uid: String, pwd: String): Boolean =
136       mapPasswords.getOrElse(uid,pwd+"!") == pwd
137   }
138 
139   //val r = interactLoginDSL.foldMap(userLogin).run(UserPasswords)
140   //println(r)
141   userLoginDSL.foldMap(userLogin).run(UserPasswords)
142 
143 }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


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

-Advertisement-
Play Games
更多相關文章
  • 文件及文件夾操作- File類、Directory 類、FileInfo 類、DirectoryInfo 類
    文件及文件夾操作： C/S：WinForm可以操作客戶端文件 Client ServerB/S：Brower Server 命名空間：using system .IO; 1. File類： 創建：File.Create(路徑);創建文件,返回FileStream FileStream fs = Fi ...
  • C#窗體 自定義控制項
    1 using System; 2 using System.Collections.Generic; 3 using System.ComponentModel; 4 using System.Drawing; 5 using System.Data; 6 using System.Linq; 7 ...
  • 進程與線程
    進程：進程是一個具有獨立功能的程式關於某個數據集合的一次運行活動。它可以申請和擁有系統資源，是一個動態的概念，是一個活動的實體。Process 類，用來操作進程。 命名空間：using System.Diagnostics; Process.Start("calc"); //計算器Process.S ...
  • 『隨筆』C# 程式 修改 ConfigurationManager 後，不重啟 刷新配置
    基本共識： ConfigurationManager 自帶緩存，且不支持 寫入。 如果 通過 文本寫入方式 修改 配置文件，程式 無法刷新載入 最新配置。 PS. Web.config 除外：Web.config 修改後，網站會重啟 （即 Web 程式 也無法在 運行時 刷新配置）。 為什麼要在程式 ...
  • ASP.NET 一句代碼實現批量數據綁定
    摘要：對於一個以數據處理為主的應用中的UI層，我們往往需要編寫相當多的代碼去實現數據綁定。如果界面上的控制項和作為數據源的實體類型之間存儲某種約定的映射關係，我們就可以實現批量的數據綁定，作者開發了的插件正是用於此，本篇著重介紹如何通過這個組件來解決我們在進行數據綁定過程中的常見問題。 對於一個以數據 ...
  • 11年 C# 4.0四大新特性代碼示例與解讀
    摘要：今天我們結合代碼實例來具體看一下C#4.0中的四個比較重要的特性。 之前的文章中，我們曾介紹過C#的歷史及C# 4.0新增特性，包括：dynamic、 命名和可選參數、動態導入以及協變和逆變等。今天我們結合代碼實例來具體看一下C#4.0中的四個比較重要的特性。 1．dynamic Expand ...
  • Asp.Net Core 項目實戰之許可權管理系統（0） 無中生有
    0 前言 http://www.cnblogs.com/fonour/p/5848933.html 學習的最好方法就是動手去做，這裡以開發一個普通的許可權管理系統的方式來從零體驗和學習Asp.net Core。項目的整體規劃大致如下： 技術路線 Asp.net Core Mvc EntityFrame ...
  • C#，簡單的郵件發送功能，郵件輔助類
    這個幫助類只能發送簡單的基本郵件，只能發送給多個用戶，單一內容。不具有抄送功能，附件添加功能。功能代碼如下， 值得註意的是，使用QQ郵箱時，發件人密碼使用的是QQ郵箱獨立密碼 在winform程式測試有效，關於在web頁面使用，有待測試。 歡迎大家一起來和我討論C#相關知識。關註我吧！ ...
一周排行
    -Advertisement-
    Play Games
  • 記一次 .NET某機械臂上位系統 卡死分析
    一：背景 1. 講故事 前些天有位朋友找到我，說他們的程式會偶發性的卡死一段時間，然後又好了，讓我幫忙看下怎麼回事？窗體類的程式解決起來相對來說比較簡單，讓朋友用procdump自動抓一個卡死時的dump，拿到dump之後，上 windbg 說話。 二：WinDbg 分析 1. 主線程在做什麼 要想 ...
  • C#控制項ListView支持添加TextBox\PictureBox等其他控制項
    功能說明 使用ListView時，希望可以在單元格顯示圖片或其他控制項，發現原生的ListView不支持，於是通過拓展，實現ListView可以顯示任意控制項的功能，效果如下： 實現方法 本來想著在單元格裡面實現控制項的自繪的，但是沒找到辦法，最後是通過在單元格的錶面顯示對應控制項的，浮於錶面達到目的。 實 ...
  • 【New Relic】給基於.NET Framework 4.0 的 exe 程式安裝New Relic
    由於.NET Framework 4.0 是比較古老的版本，只有New Relic 7.0以下的版本才會支持.NET Framework 4.0的引用程式。 Technical support for .NET Framework 4.0 or lower 你可以參考這個官方Install New ...
  • XAF 屬性編輯器（PropertyEditor）- 原理篇
    前言 隨著 DEV24.1.3 的發佈，XAF Blazor 中的屬性編輯器（PropertyEditor）也進行了很大的改動，在使用體驗上也更接近 WinForm 了，由於進行了大量的封裝，理解上沒有 WinForm 直觀，所以本文通過對屬性編輯器的原理進行解析，並對比新舊版本中的變化，使大家能夠 ...
  • 使用C#開發OPC UA伺服器
    OPC基金會提供了OPC UA .NET標準庫以及示常式序，但官方文檔過於簡單，光看官方文檔和示常式序很難弄懂OPC UA .NET標準庫怎麼用，花了不少時間摸索才略微弄懂如何使用，以下記錄如何從一個控制台程式開發一個OPC UA伺服器。 安裝Nuget包 安裝OPCFoundation.NetSt ...
  • dotnet 將本地的 Phi-3 模型與 SemanticKernel 進行對接
    今天在技術群里，石頭哥向大家提了個問題："如何在一個以System身份運行的.NET程式（Windows Services）中，以其它活動的用戶身份啟動可互動式進程（桌面應用程式、控制台程式、等帶有UI和互動式體驗的程式）"？ 我以前有過類似的需求，是在GitLab流水線中運行帶有UI的自動化測試程 ...
  • .NET 8 中的後臺服務：IHostedService 和 BackgroundService
    .Net 中提供了一系列的管理對象集合的類型，數組、可變列表、字典等。從類型安全上集合分為兩類，泛型集合 和 非泛型集合，傳統的非泛型集合存儲為Object，需要類型轉。而泛型集合提供了更好的性能、編譯時類型安全，推薦使用。 ...
  • 在Winform程式中動態繪製系統名稱，代替圖片硬編碼名稱
    在以前我做程式的時候，一般在登錄視窗裡面顯示程式名稱，登錄視窗一般設置一張背景圖片，由於程式的名稱一般都是確定的，所以也不存在太大的問題，不過如果客戶定製不同的系統的時候，需要使用Photoshop修改下圖層的文字，再生成圖片，然後替換一下也可以了。不過本著減少客戶使用繁瑣性，也可以使用空白名稱的通... ...
  • 聊一聊 Monitor.Wait 和 Pulse 的底層玩法
    一：背景 1. 講故事 在dump分析的過程中經常會看到很多線程卡在Monitor.Wait方法上，曾經也有不少人問我為什麼用 !syncblk 看不到 Monitor.Wait 上的鎖信息，剛好昨天有時間我就來研究一下。 二：Monitor.Wait 底層怎麼玩的 1. 案例演示 為了方便講述，先 ...
  • .NET-9-電腦思想-構建器模式(Builder Pattern)
    目錄前言學習參考過程總結: 前言 做個自由仔。 學習參考 ChatGpt; https://www.cnblogs.com/zhili/p/DesignPatternSummery.html(大佬的，看了好多次) 過程 原由： 一開始只是想查查鏈式調用原理，以為是要繼承什麼介面,實現什麼方法才可以實 ...
所有分類