diff --git a/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs b/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs
new file mode 100644
index 0000000000..a4675599c3
--- /dev/null
+++ b/UnitsNet.Tests/Helpers/TypeDescriptorContext.cs
@@ -0,0 +1,80 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+
+namespace UnitsNet.Tests.Helpers
+{
+    /// <summary>
+    /// Is used to imitate e property with attributes
+    /// </summary>
+    public class TypeDescriptorContext : ITypeDescriptorContext
+    {
+        public class PropertyDescriptor_ : PropertyDescriptor
+        {
+            public PropertyDescriptor_(string name, Attribute[] attributes) : base(name, attributes)
+            {
+            }
+
+            public override Type ComponentType => throw new NotImplementedException();
+
+            public override bool IsReadOnly => throw new NotImplementedException();
+
+            public override Type PropertyType => throw new NotImplementedException();
+
+            public override bool CanResetValue(object component)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override object GetValue(object component)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override void ResetValue(object component)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override void SetValue(object component, object value)
+            {
+                throw new NotImplementedException();
+            }
+
+            public override bool ShouldSerializeValue(object component)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        public TypeDescriptorContext(string name, Attribute[] attributes)
+        {
+            PropertyDescriptor = new PropertyDescriptor_(name, attributes);
+        }
+
+        public IContainer Container => throw new NotImplementedException();
+
+        public object Instance => throw new NotImplementedException();
+
+        public PropertyDescriptor PropertyDescriptor { get; set; }
+
+        public object GetService(Type serviceType)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void OnComponentChanged()
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool OnComponentChanging()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/UnitsNet.Tests/QuantityTypeConverterTest.cs b/UnitsNet.Tests/QuantityTypeConverterTest.cs
new file mode 100644
index 0000000000..94dbac7d04
--- /dev/null
+++ b/UnitsNet.Tests/QuantityTypeConverterTest.cs
@@ -0,0 +1,315 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+using System.Reflection;
+using UnitsNet.Tests.Helpers;
+using Xunit;
+
+namespace UnitsNet.Tests
+{
+    public class QuantityTypeConverterTest
+    {
+        // https://stackoverflow.com/questions/3612909/why-is-this-typeconverter-not-working
+        private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            AppDomain domain = (AppDomain)sender;
+            foreach (Assembly asm in domain.GetAssemblies())
+            {
+                if (asm.FullName == args.Name)
+                {
+                    return asm;
+                }
+            }
+            return null;
+        }
+
+        static QuantityTypeConverterTest()
+        {
+            // NOTE: After this, you can use your TypeConverter.
+            AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
+        }
+
+        /// <summary>
+        /// Is used for tests that are culture dependent
+        /// </summary>
+        private static CultureInfo culture = CultureInfo.GetCultureInfo("en-US");
+
+        [Theory]
+        [InlineData(typeof(string), true)]
+        [InlineData(typeof(double), false)]
+        [InlineData(typeof(object), false)]
+        [InlineData(typeof(float), false)]
+        [InlineData(typeof(Length), false)]
+        public void CanConvertFrom_GivenSomeTypes(Type value, bool expectedResult)
+        {
+            var converter = new QuantityTypeConverter<Length>();
+
+            bool canConvertFrom = converter.CanConvertFrom(value);
+
+            Assert.Equal(expectedResult, canConvertFrom);
+        }
+
+        [Theory]
+        [InlineData(typeof(string), true)]
+        [InlineData(typeof(double), false)]
+        [InlineData(typeof(object), false)]
+        [InlineData(typeof(float), false)]
+        [InlineData(typeof(Length), false)]
+        public void CanConvertTo_GivenSomeTypes(Type value, bool expectedResult)
+        {
+            var converter = new QuantityTypeConverter<Length>();
+
+            bool canConvertTo = converter.CanConvertTo(value);
+
+            Assert.Equal(expectedResult, canConvertTo);
+        }
+
+        [Theory]
+        [InlineData("1mm", 1, Units.LengthUnit.Millimeter)]
+        [InlineData("1m", 1, Units.LengthUnit.Meter)]
+        [InlineData("1", 1, Units.LengthUnit.Meter)]
+        [InlineData("1km", 1, Units.LengthUnit.Kilometer)]
+        public void ConvertFrom_GivenQuantityStringAndContextWithNoAttributes_ReturnsQuantityWithBaseUnitIfNotSpecified(string str, double expectedValue, Enum expectedUnit)
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            var convertedValue = (Length)converter.ConvertFrom(context, culture, str);
+
+            Assert.Equal(expectedValue, convertedValue.Value);
+            Assert.Equal(expectedUnit, convertedValue.Unit);
+        }
+
+        [Theory]
+        [InlineData("1mm", 1, Units.LengthUnit.Millimeter)]
+        [InlineData("1m", 1, Units.LengthUnit.Meter)]
+        [InlineData("1", 1, Units.LengthUnit.Centimeter)]
+        [InlineData("1km", 1, Units.LengthUnit.Kilometer)]
+        public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAttribute_ReturnsQuantityWithGivenDefaultUnitIfNotSpecified(string str, double expectedValue, Enum expectedUnit)
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DefaultUnitAttribute(Units.LengthUnit.Centimeter)
+            });
+
+            var convertedValue = (Length)converter.ConvertFrom(context, culture, str);
+
+            Assert.Equal(expectedValue, convertedValue.Value);
+            Assert.Equal(expectedUnit, convertedValue.Unit);
+        }
+
+        [Theory]
+        [InlineData("1mm", 0.001, Units.LengthUnit.Meter)]
+        [InlineData("1m", 1, Units.LengthUnit.Meter)]
+        [InlineData("1", 0.01, Units.LengthUnit.Meter)]
+        [InlineData("1km", 1000, Units.LengthUnit.Meter)]
+        public void ConvertFrom_GivenQuantityStringAndContextWithDefaultUnitAndConvertToUnitAttributes_ReturnsQuantityConvertedToUnit(string str, double expectedValue, Enum expectedUnit)
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DefaultUnitAttribute(Units.LengthUnit.Centimeter),
+                new ConvertToUnitAttribute(Units.LengthUnit.Meter)
+            });
+
+            var convertedValue = (Length)converter.ConvertFrom(context, culture, str);
+
+            Assert.Equal(expectedValue, convertedValue.Value);
+            Assert.Equal(expectedUnit, convertedValue.Unit);
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenEmptyString_ThrowsNotSupportedException()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Throws<NotSupportedException>(() => converter.ConvertFrom(context, culture, ""));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenWrongQuantity_ThrowsArgumentException()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Throws<ArgumentException>(() => converter.ConvertFrom(context, culture, "1m^2"));
+        }
+
+        [Theory]
+        [InlineData(typeof(Length))]
+        [InlineData(typeof(IQuantity))]
+        [InlineData(typeof(object))]
+        public void ConvertTo_GivenWrongType_ThrowsNotSupportedException(Type value)
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+            Length length = Length.FromMeters(1);
+
+            Assert.Throws<NotSupportedException>(() => converter.ConvertTo(length, value));
+        }
+
+        [Fact]
+        public void ConvertTo_GivenStringType_ReturnsQuantityString()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+            Length length = Length.FromMeters(1);
+
+            string convertedQuantity = (string)converter.ConvertTo(length, typeof(string));
+
+            Assert.Equal("1 m", convertedQuantity);
+        }
+
+        [Fact]
+        public void ConvertTo_GivenSomeQuantitysAndContextWithNoAttributes_ReturnsQuantityStringInUnitOfQuantity()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+            Length length = Length.FromMeters(1);
+
+            string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
+
+            Assert.Equal("1 m", convertedQuantity);
+        }
+
+        [Fact]
+        public void ConvertTo_TestDisplayAsFormatting_ReturnsQuantityStringWithDisplayUnitDefaultFormating()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DisplayAsUnitAttribute(Units.LengthUnit.Decimeter)
+            });
+            Length length = Length.FromMeters(1);
+
+            string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
+
+            Assert.Equal("10 dm", convertedQuantity);
+        }
+
+        [Fact]
+        public void ConvertTo_TestDisplayAsFormatting_ReturnsQuantityStringWithDisplayUnitFormateAsValueOnly()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DisplayAsUnitAttribute(Units.LengthUnit.Decimeter, "v")
+            });
+            Length length = Length.FromMeters(1);
+
+            string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
+
+            Assert.Equal("10", convertedQuantity);
+        }
+
+        [Fact]
+        public void ConvertTo_TestDisplayAsFormattingWithoutDefinedUnit_ReturnsQuantityStringWithQuantetiesUnitAndFormatedAsValueOnly()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DisplayAsUnitAttribute(null, "v")
+            });
+            Length length = Length.FromMeters(1);
+
+            string convertedQuantity = (string)converter.ConvertTo(context, culture, length, typeof(string));
+
+            Assert.Equal("1", convertedQuantity);
+        }
+
+        [Fact]
+        public void ConvertTo_GivenSomeQuantitysAndContextWithDisplayAsUnitAttributes_ReturnsQuantityStringInSpecifiedDisplayUnit()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DisplayAsUnitAttribute(Units.LengthUnit.Decimeter)
+            });
+            Length length = Length.FromMeters(1);
+
+            string convertedQuantityDefaultCulture = (string)converter.ConvertTo(length, typeof(string));
+            string convertedQuantitySpecificCulture = (string)converter.ConvertTo(context, culture, length, typeof(string));
+
+            Assert.Equal("1 m", convertedQuantityDefaultCulture);
+            Assert.Equal("10 dm", convertedQuantitySpecificCulture);
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenDefaultUnitAttributeWithWrongUnitType_ThrowsArgumentException()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[]
+            {
+                new DefaultUnitAttribute(Units.VolumeUnit.CubicMeter)
+            });
+
+            Assert.Throws<ArgumentException>(() => converter.ConvertFrom(context, culture, "1"));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenStringWithPower_1()
+        {
+            var converter = new QuantityTypeConverter<Length>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Equal(Length.FromMeters(1), converter.ConvertFrom(context, culture, "1m"));
+            Assert.Equal(Length.FromMeters(1), converter.ConvertFrom(context, culture, "1m^1"));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenStringWithPower_2()
+        {
+            var converter = new QuantityTypeConverter<Area>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Equal(Area.FromSquareMeters(1), converter.ConvertFrom(context, culture, "1m²"));
+            Assert.Equal(Area.FromSquareMeters(1), converter.ConvertFrom(context, culture, "1m^2"));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenStringWithPower_3()
+        {
+            var converter = new QuantityTypeConverter<Volume>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Equal(Volume.FromCubicMeters(1), converter.ConvertFrom(context, culture, "1m³"));
+            Assert.Equal(Volume.FromCubicMeters(1), converter.ConvertFrom(context, culture, "1m^3"));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenStringWithPower_4()
+        {
+            var converter = new QuantityTypeConverter<AreaMomentOfInertia>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(1), converter.ConvertFrom(context, culture, "1m⁴"));
+            Assert.Equal(AreaMomentOfInertia.FromMetersToTheFourth(1), converter.ConvertFrom(context, culture, "1m^4"));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenStringWithPower_minus1()
+        {
+            var converter = new QuantityTypeConverter<CoefficientOfThermalExpansion>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K⁻¹"));
+            Assert.Equal(CoefficientOfThermalExpansion.FromInverseKelvin(1), converter.ConvertFrom(context, culture, "1K^-1"));
+        }
+
+        [Fact]
+        public void ConvertFrom_GivenStringWithPower_minus2()
+        {
+            var converter = new QuantityTypeConverter<MassFlux>();
+            ITypeDescriptorContext context = new TypeDescriptorContext("SomeMemberName", new Attribute[] { });
+
+            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg·s⁻¹·m⁻²"));
+            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg·s^-1·m^-2"));
+            Assert.Equal(MassFlux.FromKilogramsPerSecondPerSquareMeter(1), converter.ConvertFrom(context, culture, "1kg*s^-1*m^-2"));
+        }
+    }
+}
diff --git a/UnitsNet/QuantityTypeConverter.cs b/UnitsNet/QuantityTypeConverter.cs
new file mode 100644
index 0000000000..0b0ab77a77
--- /dev/null
+++ b/UnitsNet/QuantityTypeConverter.cs
@@ -0,0 +1,263 @@
+// Licensed under MIT No Attribution, see LICENSE file at the root.
+// Copyright 2013 Andreas Gullberg Larsen (andreas.larsen84@gmail.com). Maintained at https://github.com/angularsen/UnitsNet.
+
+using System;
+using System.ComponentModel;
+using System.Globalization;
+
+namespace UnitsNet
+{
+    /// <summary>
+    /// Is the base class for all attributes that are related to <see cref="QuantityTypeConverter{T}"/>
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
+    public abstract class UnitAttributeBase : Attribute
+    {
+        /// <summary>
+        /// The unit enum type, such as <see cref="UnitsNet.Units.LengthUnit" />
+        /// </summary>
+        public Enum UnitType { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnitAttributeBase"/> class.
+        /// </summary>
+        /// <param name="unitType"></param>
+        public UnitAttributeBase(object unitType)
+        {
+            UnitType = unitType as Enum;
+        }
+    }
+
+    /// <summary>
+    /// This attribute defines the default Unit to use if the string to convert only consists of digits
+    /// </summary>
+    public class DefaultUnitAttribute : UnitAttributeBase
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultUnitAttribute"/> class.
+        /// </summary>
+        /// <param name="unitType">The unit the quantity gets when the string parsing dose only consist of digits</param>
+        public DefaultUnitAttribute(object unitType) : base(unitType) { }
+    }
+
+    /// <summary>
+    /// This attribute defines the Unit the quantity is converted to after it has been parsed.
+    /// </summary>
+    public class ConvertToUnitAttribute : DefaultUnitAttribute
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConvertToUnitAttribute"/> class.
+        /// </summary>
+        /// <param name="unitType">The unit the quantity is converted to when parsing from string</param>
+        public ConvertToUnitAttribute(object unitType) : base(unitType) { }
+    }
+
+    /// <summary>
+    /// This attribute defines the unit the quantity has when converting to string
+    /// </summary>
+    public class DisplayAsUnitAttribute : DefaultUnitAttribute
+    {
+        /// <summary>
+        /// The formating used when the quantity is converted to string. See <see cref="IQuantity.ToString(System.IFormatProvider)"/>
+        /// </summary>
+        public string Format { get; set; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DisplayAsUnitAttribute"/> class.
+        /// </summary>
+        /// <param name="unitType">The unit the quantity should be displayed in</param>
+        /// <param name="format">Formating string <see cref="IQuantity.ToString(System.IFormatProvider)"/> </param>
+        public DisplayAsUnitAttribute(object unitType, string format = "") : base(unitType)
+        {
+            Format = format;
+        }
+    }
+
+    /// <summary>
+    /// <para>
+    ///     Converts between IQuantity and string.
+    ///     Implements a TypeConverter for IQuantitys. This allows eg the PropertyGrid to read and write properties of type IQuantity.
+    /// </para>
+    ///   <para>For basic understanding of TypeConverters consult the .NET documentation.</para>
+    /// </summary>
+    /// <typeparam name="TQuantity">Quantity value type, such as <see cref="Length"/> or <see cref="Mass"/>.</typeparam>
+    /// <remarks>
+    /// <para>
+    ///     When a string is converted a Quantity the unit given by the string is used.
+    ///     When no unit is given by the string the base unit is used.
+    ///     The base unit can be overwritten by use of the <see cref="DefaultUnitAttribute"/>.
+    ///     The converted Quantity can be forced to be in a certain unit by use of the <see cref="ConvertToUnitAttribute"/>.
+    /// </para>
+    /// <para>
+    ///     The displayed unit can be forced to a certain unit by use of the <see cref="DisplayAsUnitAttribute"/>.
+    ///     The <see cref="DisplayAsUnitAttribute"/> provides the possibility to format the displayed Quantity.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    ///   <para>These examples show how to use this TypeConverter.</para>
+    ///
+    /// <code title="Using the TypeConverter without additional attributes">
+    ///     [TypeConverter(typeof(UnitsNetTypeConverter{Length}))]
+    ///     Units.Length PropertyName { get; set; }
+    /// </code>
+    ///
+    /// <code title="Using the TypeConverter with DisplayAsUnit attribute">
+    ///     [DisplayAsUnit(UnitsNet.Units.LengthUnit.Meter)]
+    ///     [TypeConverter(typeof(UnitsNetTypeConverter{Length}))]
+    ///     Units.Length Length { get; set; }
+    /// </code>
+    ///
+    /// <code title="Using the TypeConverter with DisplayAsUnit attribute with formating">
+    ///     [DisplayAsUnit(UnitsNet.Units.LengthUnit.Meter, "g")]
+    ///     [TypeConverter(typeof(UnitsNetTypeConverter{Length}))]
+    ///     Units.Length Length { get; set; }
+    /// </code>
+    ///
+    /// <code title="Using the TypeConverter with ConvertToUnit attribute">
+    ///     [ConvertToUnitAttribute(UnitsNet.Units.LengthUnit.Meter)]
+    ///     [TypeConverter(typeof(UnitsNetTypeConverter{Length}))]
+    ///     Units.Length Length { get; set; }
+    /// </code>
+    ///
+    /// <code title="Using the TypeConverter with DefaultUnit attribute">
+    ///     [DefaultUnitAttribute(UnitsNet.Units.LengthUnit.Meter)]
+    ///     [TypeConverter(typeof(UnitsNetTypeConverter{Length}))]
+    ///     Units.Length Length { get; set; }
+    /// </code>
+    /// </example>
+    public class QuantityTypeConverter<TQuantity> : TypeConverter where TQuantity : IQuantity
+    {
+        /// <summary>
+        ///     Returns true if sourceType if of type <see cref="string"/>
+        /// </summary>
+        /// <param name="context">An <see cref="System.ComponentModel.ITypeDescriptorContext"/> that provides a format context.</param>
+        /// <param name="sourceType">A <see cref="System.Type"/> that represents the type you want to convert from.</param>
+        /// <returns>true if this converter can perform the conversion; otherwise, false.</returns>
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return (sourceType == typeof(string)) || base.CanConvertFrom(context, sourceType);
+        }
+
+        private static TAttribute GetAttribute<TAttribute>(ITypeDescriptorContext context) where TAttribute : UnitAttributeBase
+        {
+            TAttribute attribute = null;
+            AttributeCollection ua = context?.PropertyDescriptor.Attributes;
+
+            attribute = (TAttribute)ua?[typeof(TAttribute)];
+
+            if (attribute != null)
+            {
+                QuantityType expected = default(TQuantity).Type;
+                QuantityType actual = QuantityType.Undefined;
+
+                if (attribute.UnitType != null) actual = Quantity.From(1, attribute.UnitType).Type;
+                if (actual != QuantityType.Undefined && expected != actual)
+                {
+                    throw new ArgumentException($"The specified UnitType:'{attribute.UnitType}' dose not match QuantityType:'{expected}'");
+                }
+            }
+
+            return attribute;
+        }
+
+        /// <summary>
+        ///     Converts the given object, when it is of type <see cref="string"/> to the type of this converter, using the specified context and culture information.
+        /// </summary>
+        /// <param name="context">An System.ComponentModel.ITypeDescriptorContext that provides a format context.</param>
+        /// <param name="culture">The System.Globalization.CultureInfo to use as the current culture.</param>
+        /// <param name="value">The System.Object to convert.</param>
+        /// <returns>An <see cref="IQuantity"/> object.</returns>
+        /// <exception cref="System.NotSupportedException">The conversion cannot be performed.</exception>
+        /// <exception cref="ArgumentException">Unit value is not a know unit enum type.</exception>
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            string stringValue = value as string;
+            object result = null;
+
+            if (!string.IsNullOrEmpty(stringValue))
+            {
+                if (double.TryParse(stringValue, NumberStyles.Any, culture, out double dvalue))
+                {
+                    DefaultUnitAttribute defaultUnit = GetAttribute<DefaultUnitAttribute>(context) ?? new DefaultUnitAttribute(default(TQuantity).Unit);
+
+                    result = Quantity.From(dvalue, defaultUnit.UnitType);
+                }
+                else
+                {
+                    // TODO this should not be part of QuantityTypeConverter. it should rather be part of the parse function
+                    stringValue = stringValue.Replace("^-9", "⁻⁹");
+                    stringValue = stringValue.Replace("^-8", "⁻⁸");
+                    stringValue = stringValue.Replace("^-7", "⁻⁷");
+                    stringValue = stringValue.Replace("^-6", "⁻⁶");
+                    stringValue = stringValue.Replace("^-5", "⁻⁵");
+                    stringValue = stringValue.Replace("^-4", "⁻⁴");
+                    stringValue = stringValue.Replace("^-3", "⁻³");
+                    stringValue = stringValue.Replace("^-2", "⁻²");
+                    stringValue = stringValue.Replace("^-1", "⁻¹");
+                    stringValue = stringValue.Replace("^1", "");
+                    stringValue = stringValue.Replace("^2", "²");
+                    stringValue = stringValue.Replace("^3", "³");
+                    stringValue = stringValue.Replace("^4", "⁴");
+                    stringValue = stringValue.Replace("^5", "⁵");
+                    stringValue = stringValue.Replace("^6", "⁶");
+                    stringValue = stringValue.Replace("^7", "⁷");
+                    stringValue = stringValue.Replace("^8", "⁸");
+                    stringValue = stringValue.Replace("^9", "⁹");
+                    stringValue = stringValue.Replace("*", "·");
+
+                    result = Quantity.Parse(culture, typeof(TQuantity), stringValue);
+                }
+
+                ConvertToUnitAttribute convertToUnit = GetAttribute<ConvertToUnitAttribute>(context);
+                if (convertToUnit != null)
+                {
+                    result = ((IQuantity)result).ToUnit(convertToUnit.UnitType);
+                }
+            }
+
+            return result ?? base.ConvertFrom(context, culture, value);
+        }
+
+        /// <summary>Returns true whether this converter can convert the <see cref="IQuantity"/> to string, using the specified context.</summary>
+        /// <returns>true if this converter can perform the conversion; otherwise, false.</returns>
+        /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
+        /// <param name="destinationType">A <see cref="T:System.Type" /> that represents the type you want to convert to. </param>
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return (destinationType == typeof(string)) || base.CanConvertTo(context, destinationType);
+        }
+
+        /// <summary>Converts the given <see cref="IQuantity"/> object to <see cref="string"/>, using the specified context and culture information.</summary>
+        /// <returns>An <see cref="T:System.Object" /> that represents the converted value.</returns>
+        /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context. </param>
+        /// <param name="culture">A <see cref="T:System.Globalization.CultureInfo" />. If null is passed, the current culture is assumed. </param>
+        /// <param name="value">The <see cref="T:System.Object" /> to convert. </param>
+        /// <param name="destinationType">The <see cref="T:System.Type" /> to convert the <paramref name="value" /> parameter to. </param>
+        /// <exception cref="T:System.ArgumentNullException">The <paramref name="destinationType" /> parameter is null. </exception>
+        /// <exception cref="T:System.NotSupportedException">The conversion cannot be performed. </exception>
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            IQuantity qvalue = value as IQuantity;
+            object result = null;
+            DisplayAsUnitAttribute displayAsUnit = GetAttribute<DisplayAsUnitAttribute>(context);
+
+            if (destinationType == typeof(string) && qvalue != null && displayAsUnit != null)
+            {
+                if (displayAsUnit.UnitType != null)
+                {
+                    result = qvalue.ToUnit(displayAsUnit.UnitType).ToString(displayAsUnit.Format, culture);
+                }
+                else
+                {
+                    result = qvalue.ToString(displayAsUnit.Format, culture);
+                }
+            }
+            else
+            {
+                result = base.ConvertTo(context, culture, value, destinationType);
+            }
+
+            return result;
+        }
+    }
+}