```html

Patrymau Dylunio yn Ruby: Gweithredu Mediator

Mae patrymau dylunio yn rhan bwysig o ddatblygu meddalwedd, gan eu bod yn cynnig dulliau sefydlog a phrofiadol i ddelio â phroblemau cyffredin. Yn yr erthygl hon, byddwn yn edrych ar y patrwm Mediator, gan ei weithredu yn Ruby. Mae'r patrwm Mediator yn caniatáu i gydrannau siarad â'i gilydd trwy gyfrwng uned ganolog, gan leihau'r cysylltiadau uniongyrchol rhyngddynt. Mae hyn yn gwneud y cod yn fwy hyblyg a hawdd i'w gynnal.

Beth yw Mediator?

Mae'r patrwm Mediator yn cynnig dull o ddelio â chydweithrediad rhwng cydrannau. Yn lle i gydrannau siarad yn uniongyrchol â'i gilydd, maent yn siarad â mediwr. Mae'r mediwr yn gyfrifol am reoli'r cyfathrebu a'r rhyngweithio rhwng y cydrannau, gan leihau'r gormod o gysylltiadau rhyngddynt. Mae hyn yn helpu i leihau'r cymhlethdod a gwella'r darllenadwyedd a'r cynnaladwyedd.

Pam Dylai Defnyddio Mediator?

Mae nifer o resymau dros ddefnyddio'r patrwm Mediator yn eich datblygiadau:

Gwell Rheolaeth: Mae'r mediwr yn caniatáu rheolaeth ganolog dros y cyfathrebu rhwng cydrannau.
Leihau Cysylltiadau: Mae lleihau'r cysylltiadau uniongyrchol yn gwneud y cod yn haws i'w gynnal.
Hyblygrwydd: Mae'n haws ychwanegu neu newid cydrannau heb effeithio ar eraill.
Darllenadwyedd: Mae'r strwythur yn gwneud y cod yn haws i'w ddeall.

Gweithredu Mediator yn Ruby

Gadewch i ni edrych ar sut i weithredu'r patrwm Mediator yn Ruby. Byddwn yn creu enghraifft sy'n cynnwys cydrannau sy'n defnyddio mediwr i gyfathrebu â'i gilydd.

Creu'r Mediwr

Yn gyntaf, byddwn yn creu'r dosbarth Mediator. Mae'r dosbarth hwn yn gyfrifol am reoli'r cydweithrediad rhwng y cydrannau.

class Mediator
  def initialize
    @colleagues = []
  end

  def register(colleague)
    @colleagues << colleague
    colleague.set_mediator(self)
  end

  def relay(message, sender)
    @colleagues.each do |colleague|
      next if colleague == sender
      colleague.receive(message)
    end
  end
end

Creu Cydrannau

Yna, byddwn yn creu dosbarthiadau ar gyfer y cydrannau sy'n cyfathrebu trwy'r mediwr. Byddwn yn creu dau gydran: CydranA a CydranB.

class Colleague
  attr_accessor :mediator

  def set_mediator(mediator)
    @mediator = mediator
  end
end

class ColleagueA < Colleague
  def send(message)
    puts "CydranA yn anfon: #{message}"
    mediator.relay(message, self)
  end

  def receive(message)
    puts "CydranA wedi derbyn: #{message}"
  end
end

class ColleagueB < Colleague
  def send(message)
    puts "CydranB yn anfon: #{message}"
    mediator.relay(message, self)
  end

  def receive(message)
    puts "CydranB wedi derbyn: #{message}"
  end
end

Defnyddio'r Mediwr a'r Cydrannau

Na, gadewch i ni ddefnyddio'r mediwr a'r cydrannau. Byddwn yn creu mediwr, yn cofrestru'r cydrannau, ac yna'n anfon neges o un cydran i'r llall.

mediator = Mediator.new
colleague_a = ColleagueA.new
colleague_b = ColleagueB.new

mediator.register(colleague_a)
mediator.register(colleague_b)

colleague_a.send("Helo o CydranA")
colleague_b.send("Helo o CydranB")

Canlyniadau

Wrth redeg y cod uchod, byddwn yn gweld y canlyniadau canlynol:

CydranA yn anfon: Helo o CydranA
CydranB wedi derbyn: Helo o CydranA
CydranB yn anfon: Helo o CydranB
CydranA wedi derbyn: Helo o CydranB

Mae'r mediwr yn sicrhau bod y neges yn mynd o un cydran i'r llall heb iddynt siarad yn uniongyrchol â'i gilydd. Mae hyn yn dangos sut mae'r patrwm Mediator yn gweithio yn ymarferol.

Fanteision a Gwrthdaro

Fel gyda phob patrwm dylunio, mae gan y patrwm Mediator ei fanteision a'i anfanteision:

Manteision

Hawdd i'w gynnal: Mae'r strwythur yn gwneud y cod yn haws i'w gynnal.
Gwell Rheolaeth: Mae'r mediwr yn caniatáu rheolaeth ganolog dros gyfanwaith y system.
Hyblygrwydd: Mae'n haws ychwanegu cydrannau newydd heb effeithio ar y rhai presennol.

Anfanteision

Gormod o Drosglwyddo: Gall y mediwr ddod yn gormodol os yw'n rheoli gormod o gydrannau.
Perthynas Gwan: Gall y cysylltiad rhwng y cydrannau a'r mediwr fod yn wan, gan fod y cydrannau yn dibynnu ar y mediwr i gyfathrebu.

Casgliad

Mae'r patrwm Mediator yn ffordd effeithiol o reoli cyfathrebu rhwng cydrannau yn eich cymwysiadau Ruby. Mae'n cynnig dull syml ond pwerus o leihau cymhlethdod a gwella cynnaladwyedd. Drwy ddefnyddio'r mediwr, gallwch sicrhau bod eich cydrannau yn gweithio gyda'i gilydd heb orfod siarad yn uniongyrchol â'i gilydd, gan greu cod mwy hyblyg a hawdd i'w ddeall.

Wrth i chi ddatblygu eich sgiliau Ruby, ystyriwch ddefnyddio'r patrwm Mediator pan fyddwch yn delio â chydweithrediadau cymhleth. Mae'n cynnig dull clir a thryloyw o reoli cyfathrebu, gan ei gwneud yn well ar gyfer prosiectau mawr neu gymhleth.

```