I am tasked with creating a payment module which consists of different types of payment methods.
There are different kind of objects that can go in each which can slightly change how some formulas are calculated. IE if a certain property is present, no tax is taken out. This is how I am currently going about it.
public abstract class Payment
{
private readonly PersonToPay _personToPay;
public Payment (PersonToPay personToPay)
{
_personToPay = personToPay;
}
public decimal PayFrom {get; set;}
public decimal PayTo {get; set;}
public decimal PayRate {get; set;}
public decimal Gross {get; set;}
public decimal Tax {get; set;}
public void CalculateGross()
{
return PayRate * [days in period]
}
public void CalculateTax()
{
if (_personToPay.IsTypeOfX)
Tax = 0;
else
Tax = PayRate * .1;
}
public virtual int GetDaysToPay()
{
int totalDays = 0;
for (var x in _personToPay.ListOfItems)
{
if (x == someTypeOfValue)
totalDays++;
}
return totalDays;
}
}
I am trying to take all of the functionality in this class and pass it to other classes but since all of the functionality is tied to the 'PersonToThePay' object that is injected, how can I do as such in the derived classes? An example would be the following:
public PaymentMethodA : Payment
{
private readonly PersonToPay _personToPay;
public PaymentMethodA(PersonToPay personToPay)
{
_personToPay = personToPay; // this personToPay would set the parent classes PersonToPay above to this
}
public int PaymentMethodAProperty;
public override int GetDaysToPay()
{
return PaymentMethodAProperty * 2;
//do PaymentMethodA logic here
}
}
I was thinking I could just make the PersonToPay a property but if you can't make a payment without a payee, doesn't it make more sense for it to be injected? I was also looking into the strategy pattern for this but to me the template seems to make more sense. Although the functionality is largely the same now, I am trying to make it as adaptable to change as possible hence the separate classes.
Any insight into what would be best to do here would be greatly appreciated.
I see two questions here: The first is what's a good pattern. It's subjective but I'd use a strategy pattern as well. Something to allow the implementation to be something that doesn't care what the payment is:
IPayment payment = new Payment() { PaymentAmount = 100 };
IPayment nonProfitPayment = new NonProfitPayment() { PaymentAmount = 100 };
Console.WriteLine($"Total for 100 payment: ${payment.TotalPayment()}");
Console.WriteLine($"Total for 100 payment: ${nonProfitPayment.TotalPayment()}");
Which of course gives: $106.00 and $100.
The class definitions being:
public interface IPayment
{
decimal TaxRate { get; set; }
decimal PaymentAmount { get; set; }
decimal TotalPayment();
}
public class Payment : IPayment
{
public Payment()
{
TaxRate = 0.06M;
}
public decimal TaxRate { get; set; }
public decimal PaymentAmount { get; set; }
public decimal TotalPayment()
{
return PaymentAmount + (PaymentAmount * TaxRate);
}
}
public class NonProfitPayment : Payment
{
public NonProfitPayment()
{
TaxRate = 0;
}
}
And then for the second question: A Payee and a Payor.
IMO these should be two additional classes, passed to a PostPayment class / Method. A Quick Pseudo class:
public class PostPayment: IPostPayment
{
public PaymentResponse PostPayment(IPayee payee, IPayor payor, IPayment payment)
{
var totalPayment = payment.TotalPayment();
var payorStatus = payor.Charge(totalPayment);
if (payorStatus == ChargeStatus.InsuffucientFunds)
{
return PaymentResponse.InsuffificientCredit;
}
return payee.Credit(totalAmount).PaymentStatus;
}
}
This ultimately ensures that any weird things for a Type of a thing, is handled by the correct thing. For additional thoughts:
public class ReallyWeirdPayeeCase : IPayee
{
public PaymentStatus Credit(decimal paymentAmount)
{
var approval = new ApprovalRequired()
{
ApprovalRequired = true,
Amount = paymentAmount,
DaysHoldRequired = 30
};
dbContext.CorporateApproval.Add(approvalRequired);
return PaymentStatus.ThirtyDayApprovalQueued;
}
}
Shooting from the hip but, I think it shows one good approach to refactoring the existing code for Single Responsibility and meeting your needs.
Related
I have a task where I need to implement a basic shopping cart system. In this shopping cart, there will be different type of campaigns which is applicable to category of products. These campaigns is going to apply different kind of discounts. To achieve this, I decided to implement the factory pattern.
Lets start with the base class for all discount types;
public abstract class Discount
{
public Category Category { get; set; }
public int MinimumItems { get; set; }
public Discount(Category category, int minItems)
{
Category = category;
MinimumItems = minItems;
}
}
The campaign interface;
public interface ICampaign
{
void ApplyDiscount(ShoppingCart card);
}
The Campaign type which is applied based on a money amount(e.g. 100 USD discount over the price);
public class AmountDiscount : Discount, ICampaign
{
public decimal DiscountAmount { get; set; }
public AmountDiscountGenerator(Category category, int minItems, decimal discountAmount) : base(category, minItems)
{
DiscountAmount = discountAmount;
}
public void ApplyDiscount(ShoppingCart card)
{
card.TotalPrice() -= DiscountAmount;
}
The Campaign type which is applied based on the rate (e.g. %20 discount over the price);
public class RateDiscountGenerator : Discount, ICampaignGenerator
{
public double DiscountRate { get; set; }
public RateDiscountGenerator(Category category, int minItems, double discountRate) : base(category, minItems)
{
DiscountRate = discountRate;
}
public void ApplyDiscount(ShoppingCart card)
{
card.TotalPrice() -= card.TotalPrice() * DiscountRate / 100;
}
As you can see, the different campaign classes differs on the ApplyDiscount() method's algorithm. But also, it differs about one of them has the data member named DiscountAmount and the other has DiscountRate.
Here is the factory class which I implemented;
public static class CampaignFactory
{
public static ICampaign GenerateCampaign(Category category, int minItems, int amountOrRate, DiscountType discountType)
{
if(discountType == DiscountType.Amount)
{
return new AmountDiscountGenerator(category, minItems, amountOrRate);
}
else if(discountType == DiscountType.Rate)
{
return new RateDiscountGenerator(category, minItems, amountOrRate);
}
}
}
The problem with my factory class is the parameter named amountOrRate. To initialize the properties DiscountAmount or DiscountRate, I need to have a common parameter in my factory class, but since this properties are semantically different, it looks wrong to me to accept a common parameter in my factory method and both campaign class constructors is going to share it(you can understand my confusion from the naming of the parameter amountOrRate).
Can you help me to implement the pattern on this particular example? You can also advice me if I need to implement different design patterns with factory pattern(e.g. strategy pattern). Any help is appreciated, thanks.
It may be overkill, but one approach would be to have an IInitializer interface, derived with initialization data for each discount type:
public interface IInitializer
{
}
public class AmountInitializer : IInitializer
{
public decimal Amount {get; set;}
}
public class RateInitializer : IInitializer
{
public double Rate{get; set;}
}
public static ICampaign GenerateCampaign(Category category, int minItems, IInitializer init)
{
if(init is AmountInitializer )
return new AmountDiscountGenerator(category, minItems, (AmountInitializer)init);
else if(init is RateInitializer)
return new RateDiscountGenerator(category, minItems, (RateInitializer)init);
}
I've not shown everything, but you should be able to fill in the gaps. Also, the actual factory could be done more neatly than an if/else chain.
When you read this you'll be awfully tempted to give advice like "this is a bad idea for the following reason..."
Bear with me. I know there are other ways to approach this. This question should be considered trivia.
Lets say you have a class "Transaction" that has properties common to all transactions such as Invoice, Purchase Order, and Sales Receipt.
Let's take the simple example of Transaction "Amount", which is the most important monetary amount for a given transaction.
public class Transaction
{
public double Amount { get; set; }
public TxnTypeEnum TransactionType { get; set; }
}
This Amount may have a more specific name in a derived type... at least in the real world. For example, the following values are all actually the same thing:
Transaction - Amount
Invoice - Subtotal
PurchaseOrder - Total
Sales Receipt - Amount
So now I want a derived class "Invoice" that has a Subtotal rather than the generically-named Amount. Ideally both of the following would be true:
In an instance of Transaction, the Amount property would be visible.
In an instance of Invoice, the Amount property would be hidden, but the Subtotal property would refer to it internally.
Invoice looks like this:
public class Invoice : Transaction
{
new private double? Amount
{
get
{
return base.Amount;
}
set
{
base.Amount = value;
}
}
// This property should hide the generic property "Amount" on Transaction
public double? SubTotal
{
get
{
return Amount;
}
set
{
Amount = value;
}
}
public double RemainingBalance { get; set; }
}
But of course Transaction.Amount is still visible on any instance of Invoice.
Thanks for taking a look!
Thanks for all the help.
OK, of course you cannot "hide" public properties on the base class when the derived class IS a base instance. Somewhere deep in my brain I already knew that. Doh!
I wound up getting the syntactic sugar to behave the way I wanted for the consumer by using a third class called TransactionBase. This class is abstract and contains the shared, non-aliased stuff that exists for all transactions like currency, exchange rate, created/modified date and time, transaction date, etc... in addition to aliased stuff like Amount.
Here, I just show the Amount property in question:
public abstract class TransactionBase
{
protected virtual double Amount { get; set; }
}
Then Transaction looks like this:
public class Transaction : TransactionBase
{
public new double Amount
{
get
{
return base.Amount;
}
set
{
base.Amount = value;
}
}
}
And Invoice:
public class Invoice : TransactionBase
{
public double SubTotal
{
get
{
return Amount;
}
set
{
Amount = value;
}
}
}
And access works the way I wanted:
var transaction = new Transaction();
// This line works fine:
var transactionAmount = transaction.Amount;
var invoice = new Invoice();
// This line works fine:
var invoiceSubtotal = invoice.SubTotal;
// This line won't compile.
// Error: TransactionBase.Amount is inaccessible due to its protection level.
var invoiceAmount = invoice.Amount;
So the answer to my original question was, "no" you cannot hide public inherited members. The above solution fakes it with accessing the protected member directly in the derived types, but it still sort of sucks. Too much typing.
Of course, now that I fiddled and piddled with all that, I'm seeing that a better solution throws out the protected members altogether and saves me some typing. By the way, YES I am embarrassed that I didn't jump immediately to this solution.
EDIT: Actually, the first appraoch in my answer might be better. With the 2nd one, I'd lose the "Amount" or "Subtotal" when casting from a Transaction to an Invoice.
public abstract class TransactionBase
{
// There are some shared properties here.
}
public class Transaction : TransactionBase
{
public double Amount { get; set; }
}
public class Invoice : TransactionBase
{
public double SubTotal { get; set; }
}
In short, you can't do this.
In long, you can emulate this by coding to interfaces!
public class Transaction
{
public double Amount { get; set; }
}
public interface IInvoice
{
public double? SubTotal { get; set; }
}
public class Invoice : Transaction, IInvoice
{
public double? SubTotal
{
get
{
return Amount;
}
set
{
Amount = value ?? 0.0f;
}
}
}
I would recommend using composition over inheritance in this instance. The main reason is that the base implementation of Transaction seems to possibly never be used in the way intended through inheritance. You can hide the transaction as a protected or private member of the Invoice and expose / manipulate it using the public properties of Invoice.
One such example could look like:
public class Invoice
{
private readonly Transaction _transaction;
public Invoice():this(new Transaction())
{
}
public Invoice(Transaction transaction)
{
_transaction = transaction;
}
// This property should hide the generic property "Amount" on Transaction
public double? SubTotal
{
get
{
return _transaction.Amount;
}
set
{
_transaction.Amount = value ?? 0.0f;
}
}
public double RemainingBalance { get; set; }
}
The exact behavior you're looking for doesn't make sense syntactically. If Invoice inherits Transaction, then it is a kind of transaction, and the compiler requires it to inherit all of its properties.
The general behavior you're looking for is, I think, encapsulation, which can be accomplished with interfaces.
public interface IInvoice
{
double? Amount { get; set; }
}
public interface ITransaction
{
double? SubTotal { get; set; }
}
Require the consumers of your code to use these interfaces, and then the implementation details are hidden to them.
So now, the classes can behave the way you want. SubTotal will still be visible to the class (Invoice), but will be hidden to the interface (IInvoice).
public class Transaction : ITransaction
{
public double? SubTotal { get; set; }
}
public class Invoice : IInvoice
{
public double? Amount
{
get { return base.SubTotal; }
set { base.SubTotal = value; }
}
}
How about using an implicit conversion operator?
class Program
{
static void Main(string[] args)
{
var transaction = new Transaction();
var transactionAmount = transaction.Amount;
var invoice = new Invoice();
var invoiceSubTotal = invoice.SubTotal;
Transaction fromInvoiceToTrans = invoice;
var fromInvoiceToTransAmount = fromInvoiceToTrans.Amount;
}
}
public class Transaction
{
public decimal Amount {get; set;}
}
public class Invoice
{
public decimal SubTotal
{
get;
set;
}
public static implicit operator Transaction(Invoice invoice)
{
return new Transaction
{
Amount = invoice.SubTotal
};
}
}
I'm currently developing an app using ASP.NET MVC3 and Entity Framework 4.1 Code First and also trying to apply DDD little by little since I'm only began learning it.
I have a model of :
public class ClassA
{
public decimal MonthlyRate { get; set; }
public virtual decimal DailyRate
{
get { return this.MonthlyRate / 30; }
private set { }
}
}
Right now, this code works but what if I'll be having a flag (which will be checked by user) on the View triggering for a new computation. Let's say the flag instead of dividing it by 30, monthly rate now will be divided by 5. Any suggestions? Thanks.
interface IDivideLogic
{
int DivideNumber{get;set;}
}
class DivideLogic : IDivideLogic
{
public DivideLogic()
{
DivideNumber = 30;
}
public DivideLogic(int divideNumber)
{
DivideNumber = divideNumber;
}
public int DivideNumber{get;set;}
}
public class ClassA
{
public IDivideLogic DivideLogic {get;set;}
public decimal MonthlyRate { get; set; }
public virtual decimal DailyRate
{
get { return this.MonthlyRate / DivideLogic.DivideNumber; }
private set { }
}
}
then you can switch this when you want
ClassA obj = new ClassA();
obj.DivideLogic = new DivideLogic(5);
This works well for more complicated situations. In your situation it may be too over designed. Hope you get the point
You could use a strategy pattern for this. You could use various implementations of your division logic. Assuming you want to anticipate further change this would be a good way to solve this problem. This way you abstract the division logic from the other logic making it easy to implement different implementations of the division logic.
You can declare the value as a property and assign it from UI.
public class ClassA
{
public decimal MonthlyRate { get; set; }
public int YourProperty {get; set;}
public ClassA(int yourProperty)
{
YourProperty = yourProperty;
}
public virtual decimal DailyRate
{
get { return this.MonthlyRate / YourProperty; }
private set { }
}
}
I have an application that I'm trying to build with at least a nominally DDD-type domain model, and am struggling with a certain piece.
My entity has some business logic that uses some financial calculations and rate calculations that I currently have inside some domain services, as well as some constant values I'm putting in a value object.
I'm struggling with how to have the entity use the logic inside the domain services, or whether the logic inside those services even belongs there. This is what I have so far:
public class Ticket
{
public Ticket(int id, ConstantRates constantRates, FinancialCalculationService f, RateCalculationService r)
{
Id = id;
ConstantRates = constantRates;
FinancialCalculator = f;
RateCalculator = r;
}
private FinancialCalculationService FinancialCalculator { get; set; }
private RateCalculationService RateCalculator { get; set; }
private ConstantRates ConstantRates { get; set; }
public int Id { get; private set; }
public double ProjectedCosts { get; set; }
public double ProjectedBenefits { get; set; }
public double CalculateFinancialGain()
{
var discountRate = RateCalculator.CalculateDiscountRate(ConstantRates.Rate1, ConstantRates.Rate2,
ConstantRates.Rate3);
return FinancialCalculator.CalculateNetPresentValue(discountRate,
new[] {ProjectedCosts*-1, ProjectedBenefits});
}
}
public class ConstantRates
{
public double Rate1 { get; set; }
public double Rate2 { get; set; }
public double Rate3 { get; set; }
}
public class RateCalculationService
{
public double CalculateDiscountRate(double rate1, double rate2, double rate3 )
{
//do some jibba jabba
return 8.0;
}
}
public class FinancialCalculationService
{
public double CalculateNetPresentValue(double rate, params double[] values)
{
return Microsoft.VisualBasic.Financial.NPV(rate, ref values);
}
}
I feel like some of that calculation logic does belong in those domain services, but don't really like that I'll have to manually inject those dependencies from my Repository. Is there an alternate way that this should be modeled? Am I wrong in not liking that?
Having read the Blue Book but not really built anything in this style before, I'm looking for guidance.
EDIT
Thanks all for the feedback! Based on what I'm hearing, it sounds like my model should look more like the following. This look better?
public class Ticket
{
public Ticket(int id)
{
Id = id;
}
private ConstantRates ConstantRates { get; set; }
public int Id { get; private set; }
public double ProjectedCosts { get; set; }
public double ProjectedBenefits { get; set; }
public double FinancialGain { get; set; }
}
public class ConstantRates
{
public double Rate1 { get; set; }
public double Rate2 { get; set; }
public double Rate3 { get; set; }
}
public class FinancialGainCalculationService
{
public FinancialGainCalculationService(RateCalculationService rateCalculator,
FinancialCalculationService financialCalculator,
ConstantRateFactory rateFactory)
{
RateCalculator = rateCalculator;
FinancialCalculator = financialCalculator;
RateFactory = rateFactory;
}
private RateCalculationService RateCalculator { get; set; }
private FinancialCalculationService FinancialCalculator { get; set; }
private ConstantRateFactory RateFactory { get; set; }
public void CalculateFinancialGainFor(Ticket ticket)
{
var constantRates = RateFactory.Create();
var discountRate = RateCalculator.CalculateDiscountRate(constantRates.Rate1, constantRates.Rate2,
constantRates.Rate3);
ticket.FinancialGain = FinancialCalculator.CalculateNetPresentValue(discountRate,
new[] {ticket.ProjectedCosts*-1, ticket.ProjectedBenefits});
}
}
public class ConstantRateFactory
{
public ConstantRates Create()
{
return new ConstantRates();
}
}
public class RateCalculationService
{
public double CalculateDiscountRate(double rate1, double rate2, double rate3 )
{
//do some jibba jabba
return 8.0;
}
}
public class FinancialCalculationService
{
public double CalculateNetPresentValue(double rate, params double[] values)
{
return Microsoft.VisualBasic.Financial.NPV(rate, ref values);
}
}
The domain model ends up being fairly anemic at this point, but as I add features maybe it'll have more to it.
EDIT 2
Okay, I got some more feedback that perhaps my 'calculation' services are more like strategy objects that it's okay for my Entity to depend on. Here's another take at it with more of the logic back in the Entity, and making use of those strategy objects. Thoughts on this? Any issues with instantiating those helpers directly in the Entity? I don't think I'll want to mock those out in my tests, but OTOH I can't test the CalculateFinancialGain method without testing those strategy objects, either.
public class Ticket
{
public Ticket(int id, ConstantRates constantRates)
{
Id = id;
ConstantRates = constantRates;
}
private ConstantRates ConstantRates { get; set; }
public int Id { get; private set; }
public double ProjectedCosts { get; set; }
public double ProjectedBenefits { get; set; }
public double CalculateFinancialGain()
{
var rateCalculator = new RateCalculator();
var financeCalculator = new FinanceCalculator();
var discountRate = rateCalculator.CalculateDiscountRate(ConstantRates.Rate1, ConstantRates.Rate2,
ConstantRates.Rate3);
return financeCalculator.CalculateNetPresentValue(discountRate,
ProjectedCosts*-1,
ProjectedBenefits);
}
}
public class ConstantRates
{
public double Rate1 { get; set; }
public double Rate2 { get; set; }
public double Rate3 { get; set; }
}
public class RateCalculator
{
public double CalculateDiscountRate(double rate1, double rate2, double rate3 )
{
//do some jibba jabba
return 8.0;
}
}
public class FinanceCalculator
{
public double CalculateNetPresentValue(double rate, params double[] values)
{
return Microsoft.VisualBasic.Financial.NPV(rate, ref values);
}
}
Have your service accept the Ticket entity as a parameter. Services should be stateless and the same service should be able to provide its services to any number of entities.
In your situation I would pull the FinancialCalculatorService and RateCalculatorService out of your entity and make the methods on each service accept the Ticket entity as a parameter.
Take a second and read pg. 105 of Domain-Driven Design by Eric Evans
Given what we've seen of the classes, I don't think they're really services in the blue book sense, and I would keep the calculators in Ticket.
Neither FinancialCalculatorService or RateCalculationService has dependencies on domain entities - they both operate on primitive values. Applications shouldn't have to worry about how to calculate the financial gain that would result from a ticket, so it's valuable to encapsulate that information inside the ticket itself.
If they really don't have dependencies on domain entities, consider thinking of them as 'standalone classes' rather than 'services' (once again, in blue book terminology). It's certainly appropriate for Ticket depend on strategy objects (FinancialCalculator and RateCalculator) that do not themselves have exotic dependencies and do not themselves modify the state of domain entities.
Update for Edit 2. I think one of the advantages of making the calculators separate classes is that you can test them independently of Ticket. Strictly speaking, tickets aren't responsible for performing those calculations, they're responsible for making the right calls to those collaborating classes. So I'd be inclined to make them inject-able / mock-able as they were in your initial example.
i would say services use entities, not the other way around.
another thing, not sure on your domain, but are you certain ticket is an entity and not a value object?
You've actually struck on a question that there has been quite a bit of discussion on. There are believers on both sides of the tracks so you need to decide for yourself what makes the most sense.
Personally I don't have my entities use services as it creates a whole lot of work around the "How do I cleanly get services into my entities?" question.
It looks to me like CalculateFinancialGains() is more of a service level call. This does lead to Ticket being very anemic but I assume it has other behavior? And if it doesn't that's probably a smell...
This question is actually an example of a discussion that is in the book "Clean Code" (pp 96-97). The underlying question is whether or not to use a procedural approach or a object oriented approach. Hope I'm not in violation repeating a couple parts here, but here is what Bob Martin states for guidance:
Procedural code (code using data structures) makes it easy to add new functions without changing the existing data structures. OO code, on the other hand, makes it easy to add new classes without changing existing functions.
The compliment is also true:
Procedural code makes it hard to add new data structures because all the functions must change. OO code makes it hard to add new functions because all the classes must change.
My understanding that a DDD "Value type" would be what Bob Martin calls a data structure.
Hope this helps and doesn't just add to the noise :)
Scenario
I have a single base class and 2 (possibly 3) other classes that derive from that base class.
//Base Class
class RateInstrument
{
public string Ric { get; set; }
public string Tenor { get; set; }
public double Rate { get; set; }
public DateTime Date { get; set; }
public double Price { get; set; }
public double Bid { get; set; }
public double Ask { get; set; }
public RateInstrument(string tenor, double rate)
{
Tenor = tenor;
Rate = rate;
}
public RateInstrument(DateTime date, double price)
{
Date= date;
Price = price;
}
}
//Derived Class 1
class Swap : RateInstrument
{
public Swap(string tenor, double rate): base(tenor,rate)
{
}
}
//Derived Class 2
class Future: RateInstrument
{
public Future(DateTime date, double price): base(date,price)
{
}
}
Question
On occasions I may need to have a collection of ALL Rate Instruments, and sometimes just a collection of each individual RateInstrument itself.
Realistically what I wanted was to employ some methods in the Base class to do this however I'm not entirely sure how to go about it. It is important to me to structure the code well to help my learning etc. Any help would be greatly appreciated.
EDIT----------
Sorry I meant to say in the essence of being able to instantiate a collection of objects in shorthand. Particularly if I have to create say 100 at a time.
In C# 3.5 you don't really need to do anything in particular for that. IEnumerable<RateInstrument> will do fine.
If you want only particular subtypes, you can use the OfType extension method:
var swaps = instruments.OfType<Swap>();
Doesn't your existing code do the trick?
List<RateInstrument> instruments = new List<RateInstrument>();
instruments.Add(new Swap("bla", 100));
instruments.Add(new OtherSwap("bla2", 200));
var swapInstruments = from instrument in instruments where instrument Is Swap select instrument;