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 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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類