C# Money类代码示例

        private EntityCollection GenerateRandomAccountCollection()
        {
            var collection = new List<Entity>();
            for (var i = 0; i < 10; i++)
            {
                var rgn = new Random((int)DateTime.Now.Ticks);
                var entity = new Entity("account");
                entity["accountid"] = entity.Id = Guid.NewGuid();
                entity["address1_addressid"] = Guid.NewGuid();
                entity["modifiedon"] = DateTime.Now;
                entity["lastusedincampaign"] = DateTime.Now;
                entity["donotfax"] = rgn.NextBoolean();
                entity["new_verybignumber"] = rgn.NextInt64();
                entity["exchangerate"] = rgn.NextDecimal();
                entity["address1_latitude"] = rgn.NextDouble();
                entity["numberofemployees"] = rgn.NextInt32();
                entity["primarycontactid"] = new EntityReference("contact", Guid.NewGuid());
                entity["revenue"] = new Money(rgn.NextDecimal());
                entity["ownerid"] = new EntityReference("systemuser", Guid.NewGuid());
                entity["industrycode"] = new OptionSetValue(rgn.NextInt32());
                entity["name"] = rgn.NextString(15);
                entity["description"] = rgn.NextString(300);
                entity["statecode"] = new OptionSetValue(rgn.NextInt32());
                entity["statuscode"] = new OptionSetValue(rgn.NextInt32());
                collection.Add(entity);
            }

            return new EntityCollection(collection);
        }

 public void DivisionOfMoneyObejcts_ShouldReturnWallet()
 {
     var money1 = new Money<long>(42);
     var money2 = new Money<long>(1000);
     var actual = money1 / money2;
     actual.ShouldBeAssignableTo<Wallet<long>>();
 }

        public void MoneyHasValueEquality()
        {
            var money1 = new Money(101.5M);
            var money2 = new Money(101.5M);

            money2.ShouldBe(money1);
        }

        internal Money Round(Money money, int decimalPlaces)
        {
            decimal amount = money.Amount;
            int factor = (int) Math.Pow(10, decimalPlaces);

            // split the amount into integral and fraction parts
            decimal integral = Math.Truncate(money.Amount);
            decimal fraction = amount-integral;

            // raise the fraction by the number of decimal places to which we want to round,
            // so that we can apply integer rounding
            decimal raisedFraction = Decimal.Multiply(fraction, factor);

            // pass the raisedFraction to a template method to do the rounding according to the RoundingStrategy
            decimal roundedFraction = CalculateRoundedAmount(raisedFraction);

            // shift the decimal to the left again, by the number of decimal places
            decimal resultFraction = Decimal.Divide(roundedFraction, factor);

            // add the original integral and the rounded resultFraction back together
            decimal roundedAmount = integral + resultFraction;

            // return the result
            return new Money(money.Currency, roundedAmount, money.RoundingMode, (DecimalPlaces)money.DecimalPlaces);
        }

        public void MoneyFractionalAmountWithOverflowAdditionIsCorrect()
        {
            var money1 = new Money(100.999M);
            var money2 = new Money(0.9M);

            Assert.Equal(new Money(101.899m), money1 + money2);
        }

        public void MoneyFractionalAmountAdditionIsCorrect()
        {
            var money1 = new Money(100.00m);
            var money2 = new Money(0.01m);

            Assert.Equal(new Money(100.01m), money1 + money2);
        }

 public override void DataBind()
 {
     var splitLineItems = Shipment.GetShipmentLineItems(SplitShipment);
     var billingCurrency = CartHelper.Cart.BillingCurrency;
     if (splitLineItems != null)
     {
         OrderSubTotalLineItems.Text = new Money(splitLineItems.ToArray().Sum(x => x.ExtendedPrice) +
             splitLineItems.ToArray().Sum(x => x.OrderLevelDiscountAmount), billingCurrency).ToString();
     }
     if (SplitShipment != null)
     {
         string discountMessage = String.Empty;
         var shippingDiscountsTotal = CalculateShippingDiscounts(SplitShipment, billingCurrency, out discountMessage);
         var shippingCostSubTotal = CalculateShippingCostSubTotal(SplitShipment, CartHelper);
         shippingDiscount.Text = shippingDiscountsTotal.ToString();
         ShippingDiscountsMessage.Text = discountMessage;
         shippingTotal.Text = (shippingCostSubTotal).ToString();
     }
     else
     {
         string zeroMoney = new Money(0, SiteContext.Current.Currency).ToString();
         shippingDiscount.Text = zeroMoney;
         shippingTotal.Text = zeroMoney;
     }
 }

 public Transfer makeTransfer(string counterAccount, Money amount)
 {
     // 1. Assuming result is 9-digit bank account number, validate 11-test:
     int sum = 0; // <1>
     for (int i = 0; i < counterAccount.Length; i++)
     {
         sum = sum + (9 - i) * (int)Char.GetNumericValue(
             counterAccount[i]);
     }
     if (sum % 11 == 0)
     {
         // 2. Look up counter account and make transfer object:
         CheckingAccount acct = Accounts.FindAcctByNumber(counterAccount);
         Transfer result = new Transfer(this, acct, amount); // <2>
         // 3. Check whether withdrawal is to registered counter account:
         if (result.CounterAccount.Equals(this.RegisteredCounterAccount))
         {
             return result;
         }
         else
         {
             throw new BusinessException("Counter-account not registered!");
         }
     }
     else
     {
         throw new BusinessException("Invalid account number!!");
     }
 }

        public void CurrencyCodeShouldBeCaseIgnorant(string currency)
        {
            const Currency expectedCurrency = Currency.AUD;
            var money = new Money(42, currency);

            money.Currency.ShouldBe(expectedCurrency);
        }

 public void WhenDestinationCurrencyIsEmpty_ShouldThrow()
 {
     var m1 = new Money<decimal>(123, "USD");
     var m2 = new Money<decimal>(1, "AUD");
     var wallet = m1 + m2;
     Should.Throw<ArgumentNullException>(() => wallet.Evaluate(this.currencyConverter, null));
 }

 public void WhenCurrencyConverterIsNull_ShouldThrow()
 {
     var m1 = new Money<int>(123, "USD");
     var m2 = new Money<int>(1, "AUD");
     var wallet = m1 + m2;
     Should.Throw<ArgumentNullException>(() => wallet.Evaluate(null, "AUD"));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="T:B4F.TotalGiro.Instruments.Price">Price</see> class.
 /// </summary>
 /// <param name="money">This is the amount that one particular instrument to which the price belongs would cost</param>
 /// <param name="instrument">The instrument to which the price belongs</param>
 public Price(Money money, IInstrument instrument)
 {
     this.quantity = money.Quantity;
     this.underlying = (ICurrency)money.Underlying;
     this.instrument = instrument;
     this.XRate = money.XRate;
 }

        public void opInequality_Money_Money()
        {
            var obj = new Money(new Currency("€", 2), 1.23m);
            var comparand = new Money(new Currency("£", 2), 1.23m);

            Assert.True(obj != comparand);
        }

        public void Bid(Guid auctionId, Guid memberId, decimal amount)
        {
            try
            {
                using (DomainEvents.Register(OutBid()))
                using (DomainEvents.Register(BidPlaced()))
                {
                    var auction = _auctionRepository.FindBy(auctionId);

                    var bidAmount = new Money(amount);

                    auction.PlaceBidFor(new Bid(memberId, bidAmount, _clock.Time()), _clock.Time());

                    _auctionRepository.Save(auction);
                }

                _unitOfWork.Commit();
            }
            catch (ConcurrencyException ex)
            {
                _unitOfWork.Clear();

                Bid(auctionId, memberId, amount);
            }            
        }

 public void AdditionOfMoneyObejcts_ShouldReturnWallet()
 {
     var money1 = new Money<int>(42);
     var money2 = new Money<int>(1000);
     var actual = money1 + money2;
     actual.ShouldBeAssignableTo<Wallet<int>>();
 }