Utilizzo di classi generiche astratte nel modello di progettazione software factory

Question

Hey ragazzi Ho un po 'di problemi di progettazione. Ho creato un calcolatore di tasso come segue:

Public Interface ICalculator 
Property PaymentTerm As Double 
Function Calculate() As CommissionValues 
ReadOnly Property CalculationRule As CalculationRuleEnum 
End Interface 

Public Interface IFlexibleRateCalculator 
Inherits ICalculator 
    Property TransferRate As Decimal 
End Interface 

Public Interface IFixedRateCalculator 
Inherits ICalculator 
    Property ContractRate As Decimal 
End Interface 

Public Interface IRateSettingBase 
    Property RateType As RateTypeEnum 
    ReadOnly Property Calculator As ICalculator 
End Interface 

Public MustInherit Class RateSetting 
Implements IRateSettingBase 
    Public MustOverride ReadOnly Property Calculator() As ICalculator Implements IRateSettingBase.Calculator 

posso fare qualcosa di simile:

dim ratevalues as RateValues = RateSetting().Calculator.Calculate() 

Abbastanza semplice. Il problema è che ogni tipo di calcolatrice ha il proprio set di proprietà che devono essere impostate affinché i loro metodi Calculate() funzionino correttamente. così finisco per dover implementare come segue

FlexibleRateCalculator 
Implements IFlexibleRateCalculator 
    Private mRequestedRate As Decimal 
    Public Function Calculate() As RateValues Implements ICalculator.Calculate 

FixedRateCalculator 
Implements IFixedRateCalculator 
    Private mTransferRate As Decimal 
    Public Function Calculate() As RateValues Implements ICalculator.Calculate 

Qual è il modo migliore utilizzando farmaci generici e classi astratte per creare un modello di fabbrica che genererà una calcolatrice di un tipo specifico dinamicamente ??

Ho bisogno di una soluzione molto generica in quanto molte percentuali di calcolo verranno aggiunte e modificate tutte con i propri parametri necessari per la logica di calcolo. Voglio essere in grado di farlo rapidamente e possibilmente controllare questo calcolo della velocità tramite db. FYI risponde in C# o VB.Net sono i benvenuti :) Grazie in anticipo!

Answer 1

Conservare solo l'interfaccia ICalculator e convertire le interfacce più specifiche in classi. Non riesco a pensare a una buona ragione per cui dovresti creare una classe solo per memorizzare una variabile, quindi mi libererò del RateSetting interamente.

Public Interface ICalculator 
    Property Rate As Double 
    Property PaymentTerm As Double 
    Function Calculate() As CommissionValues 
    ReadOnly Property CalculationRule As CalculationRuleEnum 
End Interface 

Public Class FlexibleRateCalculator : Implements ICalculator 

    Public Sub New(rate As Double) 
     Me.Rate = rate 
    End Sub 

    ' 
    ' ICalculator implementation goes here 
    ' 

End Class 

Public Class FixedRateCalculator : Implements ICalculator 

    Public Sub New(rate As Double) 
     Me.Rate = rate 
    End Sub 

    ' 
    ' ICalculator implementation goes here 
    ' 

End Class 

Public Enum RateType 
    Flexible = 1 
    Fixed = 2 
End Enum 

Public Class CalculatorFactory 

    Public Shared Function GetCalculator(rate As Double, type As RateType) As ICalculator 
     Select Case type 
      Case RateType.Flexible 
       Return New FlexibleRateCalculator(rate) 
      Case RateType.Fixed 
       Return New FixedRateCalculator(rate) 
      Case Else 
       Throw New ArgumentException 
     End Select 
    End Function 

End Class 

di creare istanze di oggetti passando un tasso e un tipo di tariffa al metodo GetCalculator. Non so cosa intendi per CalculationRule, ma se è importante per l'utente finale, dovresti aggiungerlo come parametro aggiuntivo.

È possibile aggiungere facilmente più tipi di calcolatrice che implementano ICalculator, a condizione che non si dimentichi di aggiornare l'istruzione select nel metodo factory.

MODIFICA: ovviamente è anche possibile impostare proprietà aggiuntive prima di restituire un'istanza dell'oggetto. Il punto di questo schema è tuttavia quello di assicurarsi che l'utente finale non abbia bisogno di sapere come è implementato lo Calculate(). Se vuoi creare metodi di fabbrica più specifici per ogni calcolatrice, questo tipo di sconfigge lo scopo.

Answer 2

Conoscete i contenitori IoC? Dovresti essere in grado di utilizzare i servizi di tipo factory forniti per generare i tipi appropriati con parametri/proprietà appropriati in base a un determinato tipo (enum, stringa, ecc.)

In caso contrario, potresti creare una classe di fabbrica che ha un metodo che genera il tipo appropriato in base a un parametro. Questo metodo può accettare un ParamArray o un altro oggetto che contiene le proprietà necessarie per impostare correttamente la calcolatrice e quindi restituirla, tramite l'interfaccia ICalculator.