dgg / nmoneys Goto Github PK

As an effort to popularize the library, packages for the current packaging 
systems in .NET:
 * Openwrap
 * Nu
 * NuPack
 * HornGet
 * CoApp
 * whichever one you request

Sometimes passing a lowercase three-letter code is fine (as in 
Currency.Get("usd")) but sometimes it throws (new Money(10m, "usd")).

Make it consistent (and preferably case-insensitive)

It would be great if the Json.net deserializer could accept a standard decimal 
(float) value and make it into a Money data type with currency XXX. It would 
help getting data from existing services.

Suggested code:
            var token = JToken.ReadFrom(reader);

            if(!token.HasValues)
            {
                decimal value;
                if (!decimal.TryParse(token.ToString(), out value))
                    throw new ArgumentException("Invalid content");

                return new Money(value);
            }

            return new Money(
                readAmount(token),
                readCurrency(token));

While doing some research for the Ammendment 159, I discovered that CVE moneys 
are not to be formatted with a symbol.

So 12.25 CVE should be formatted as 12$25 and not $12$25.

As Money is now a class, nulls need to be handled in operator and arithmetics 
operations arguments

null + something = something
something + null = something
null + null = null
m.Add(null) = m

null - something = -something
something - null = something
null - null = null
m.Substract(null) = m

null * something = null
something * null = null
null * null = null

-null = null
...

Currencies are volatile, new currencies get added and old ones get substituted.
Currencies and moneys can be serialized somehow.


What steps will reproduce the problem?
1. have an old deprecated currency serialized
2. try to deserialize
3. the object can't be reconstructed

Explore the options to intercept the de-serialiation process.

New extensions methods to get the alphabetic and numeric codes for the 
enumeration value itself can be included

internal decimal Round(decimal share)
{
	decimal raw = share - (.5m * MinAmount);
	decimal rounded = Math.Round(raw, SignificantDecimalDigits, MidpointRounding.AwayFromZero);
	return rounded;
}

Whenever .Format() is called including the amount placeholder, the number is 
formatted according to the default .ToString(), not as a monetary amount.

In order to facilitate the approach for non-developers it would be advantageous 
if the project had a desktop executable that showed-off the features of the 
library.
A simple WPF application would do the work.

Implement empty tests

Just spotted that the ExchangeConversion class will instantiate a new Money 
even if the target currencyCode is the same as the source currencyCode.  Could 
this be optimized like this:

public Money To(CurrencyIsoCode to)
{
    if (_from.CurrencyCode == to)
        return _from;

    ExchangeRate rate = _provider.Get(_from.CurrencyCode, to);
    return rate.Apply(_from);
}

XP: framework 2, 3.5, 3.5 SP1
2003 Server: framework 2, 3.5, 3.5 SP1
Vista: framework 2, 3.5, 3.5 SP1
2008 Server: framework 2, 3.5, 3.5 SP1
W7: framework 2, 3.5, 3.5 SP1

Add a new overload to Currency.Get() and Currency.TryGet() that receives and 
instance of RegionInfo

Add:

CurrencyIsoCode Currency.Parse(string)
bool Currency.TryParse(string , out CurrencyIsoCode)
CurrencyIsoCode? Currency.TryParse(string)

CLF goes from 0 decimals to 4

Add <, >, <=, >= operator overloading to Money. Compare with Money and decimals.

Now that the information is easily available and a estrategy for obsolete 
currencies is in place, historical currencies can be added to the library from 
http://www.currency-iso.org/dl_iso_tables_a3.xls

You forgot to add this to Money so that xml serialization with web services 
works correctly, [XmlSchemaProvider("GetSchema")]

Investigate Xaml serialization for Money now that it does not depend on Currency

What steps will reproduce the problem?

1. Execute the following code in an en-US or en-GB context. 
2. Console.WriteLine(Money.Parse("€1000.00", Currency.Eur));


What is the expected output? What do you see instead?

The output is "100.000,00 €". This is partially understandable but also 
confusing. It is understandable insofar as Eurozone countries tend to use the 
period/full-stop as the thousands separator and the comma as the decimal 
separator. However, it is confusing in that the code is running in a culture 
context that reverses these symbols. I would *not* argue for a change in the 
current behaviour, but an ability to provide a NumberFormatInfo to use when 
parsing the decimal portion would be good. See below for an example 
implementation.


What version of the product are you using? On what operating system?
Version 3.5.1.0 on Windows 8.1 Update 1, .NET 4.5.


Please provide any additional information below.
Attached is a modification of Money.Parsing.cs file to add a new overload 
taking NumberFormatInfo. I would very much like for this to be merged into the 
code base. I assign the copyright to the copyright owner of the existing file, 
provide no warranty as to its usage, etc. etc.!

Implement a functionality to parse a monetary amount.

It should make use of an internal Currency instance when needed, but is state 
is made up of a decimal amount and a CurrencyIsoCode currency

When trying to make a NMoneys.Currency.Get(<<currencyIso>>) of an uninitialised 
currency from multiple concurrent System.Threading.Tasks.Task you will get:

System.ArgumentException: An item with the same key has already been added.
   at System.Collections.Generic.Dictionary`2.Insert(TKey key, TValue value, Boolean add)
   at NMoneys.Support.ThreadSafeCache`2.Add(TKey key, TValue value)
   at NMoneys.Currency.Get(CurrencyIsoCode isoCode)

You have in the attach the unit test to reproduce this.

I may suggest to use ConcurrentDictionary<TKey, TValue> to keep the initialized 
currencies.

Thank you for your useful library!

Regards,
Cosmin

Use some sort of tool to dig into the possible exceptions to be thrown

Check and test that TryXXX methods do not throw an exceptions

Add support for getting the html entity information for those currencies that 
support it.

http://www.alanwood.net/unicode/currency_symbols.html
http://www.w3schools.com/tags/ref_entities.asp

Can you please sign the output assemblies so that we can use them in other 
projects without having to sign them ourselves?

Check whether the library is CLS compliant and if so, make it splicit.
Run static anlysis on it.

Similarly to `CurrencyEqualityComparer` we can surface a faster enum comparer 
for `CurrencyIsoCode`

From 2014/01/01 Latvian lats LAT become deprecated in favor of EUR.

Xml: public class SerializationHelper<T> where T : class
{
    public string SerializeXml(T o)
    {
        var serializer = new XmlSerializer(typeof(T));

        var sb = new StringBuilder();
        using (var tw = new StringWriter(sb))
        {
            serializer.Serialize(tw, o);
        }

        return sb.ToString();
    }

    public T DeserializeXml(string text)
    {
        var serializer = new XmlSerializer(typeof(T));

        using (var tr = new StringReader(text))
        {
            return (T)serializer.Deserialize(tr);
        }
    }
}

Xaml and datacontract