diff --git a/csharp/Platform.Numbers/CalcResult.cs b/csharp/Platform.Numbers/CalcResult.cs
index eb06c42..2e3498f 100644
--- a/csharp/Platform.Numbers/CalcResult.cs
+++ b/csharp/Platform.Numbers/CalcResult.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Runtime.CompilerServices;
 
 namespace Platform.Numbers
 {
@@ -13,6 +14,8 @@ public CalcResult(T value)
         }
 
         #region Arithmetic operations
+      
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public CalcResult<T> Add(T a)
         {
             if (IsValid)
@@ -30,6 +33,7 @@ public CalcResult<T> Add(T a)
             return this;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public CalcResult<T> Subtract(T a)
         {
             if (IsValid)
@@ -47,6 +51,7 @@ public CalcResult<T> Subtract(T a)
             return this;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public CalcResult<T> Multiply(T a)
         {
             if (IsValid)
@@ -64,6 +69,7 @@ public CalcResult<T> Multiply(T a)
             return this;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public CalcResult<T> Divide(T a)
         {
             if (IsValid)
@@ -81,74 +87,107 @@ public CalcResult<T> Divide(T a)
             return this;
         }
 
-        public CalcResult<T> Add(CalcResult<T> a)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CalcResult<T> Add(CalcResult<T> cr)
         {
-            if (IsValid &= a.IsValid)
+            if (IsValid)
             {
-                try
+                if (cr.IsValid)
                 {
-                    _value = Arithmetic<T>.Add(_value, a._value);
+                    try
+                    {
+                        _value = Arithmetic<T>.Add(_value, cr._value);
+                    }
+                    catch (Exception e)
+                    {
+                        Message = e.Message;
+                        IsValid = false;
+                    }
                 }
-                catch (Exception e)
+                else
                 {
-                    Message = e.Message;
-                    IsValid = false;
+                    return cr;
                 }
             }
             return this;
         }
 
-        public CalcResult<T> Subtract(CalcResult<T> a)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CalcResult<T> Subtract(CalcResult<T> cr)
         {
-            if (IsValid &= a.IsValid)
+            if (IsValid)
             {
-                try
+                if (cr.IsValid)
                 {
-                    _value = Arithmetic<T>.Subtract(_value, a._value);
+                    try
+                    {
+                        _value = Arithmetic<T>.Subtract(_value, cr._value);
+                    }
+                    catch (Exception e)
+                    {
+                        Message = e.Message;
+                        IsValid = false;
+                    }
                 }
-                catch (Exception e)
+                else
                 {
-                    Message = e.Message;
-                    IsValid = false;
+                    return cr;
                 }
             }
             return this;
         }
 
-        public CalcResult<T> Multiply(CalcResult<T> a)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CalcResult<T> Multiply(CalcResult<T> cr)
         {
-            if (IsValid &= a.IsValid)
+            if (IsValid)
             {
-                try
+                if (cr.IsValid)
                 {
-                    _value = Arithmetic<T>.Multiply(_value, a._value);
+                    try
+                    {
+                        _value = Arithmetic<T>.Multiply(_value, cr._value);
+                    }
+                    catch (Exception e)
+                    {
+                        Message = e.Message;
+                        IsValid = false;
+                    }
                 }
-                catch (Exception e)
+                else
                 {
-                    Message = e.Message;
-                    IsValid = false;
+                    return cr;
                 }
             }
             return this;
         }
 
-        public CalcResult<T> Divide(CalcResult<T> a)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public CalcResult<T> Divide(CalcResult<T> cr)
         {
-            if (IsValid &= a.IsValid)
+            if (IsValid)
             {
-                try
+                if (cr.IsValid)
                 {
-                    _value = Arithmetic<T>.Divide(_value, a._value);
+                    try
+                    {
+                        _value = Arithmetic<T>.Divide(_value, cr._value);
+                    }
+                    catch (Exception e)
+                    {
+                        Message = e.Message;
+                        IsValid = false;
+                    }
                 }
-                catch (Exception e)
+                else
                 {
-                    Message = e.Message;
-                    IsValid = false;
+                    return cr;
                 }
             }
             return this;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public CalcResult<T> Increment()
         {
             if (IsValid)
@@ -166,6 +205,7 @@ public CalcResult<T> Increment()
             return this;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public CalcResult<T> Decrement()
         {
             if (IsValid)
@@ -184,9 +224,9 @@ public CalcResult<T> Decrement()
         }
         #endregion
 
-        public T Value 
-        { 
-            get => _value; 
+        public T Value
+        {
+            get => _value;
             set
             {
                 _value = value;
@@ -201,41 +241,221 @@ public T Value
         private T _value;
 
         #region Operator overloading
-        public static CalcResult<T> operator ++(CalcResult<T> x) => x.Increment();
-
-        public static CalcResult<T> operator --(CalcResult<T> x) => x.Decrement();
-
-        public static CalcResult<T> operator +(CalcResult<T> x, T y) => x.Add(y);
 
-        public static CalcResult<T> operator -(CalcResult<T> x, T y) => x.Subtract(y);
-
-        public static CalcResult<T> operator *(CalcResult<T> x, T y) => x.Multiply(y);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator ++(CalcResult<T> cr)
+        {
+            if (cr.IsValid)
+            {
+                try
+                {
+                    cr._value = Arithmetic<T>.Increment(cr._value);
+                }
+                catch (Exception e)
+                {
+                    cr.Message = e.Message;
+                    cr.IsValid = false;
+                }
+            }
+            return cr;
+        }
 
-        public static CalcResult<T> operator /(CalcResult<T> x, T y) => x.Divide(y);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator --(CalcResult<T> cr)
+        {
+            if (cr.IsValid)
+            {
+                try
+                {
+                    cr._value = Arithmetic<T>.Decrement(cr._value);
+                }
+                catch (Exception e)
+                {
+                    cr.Message = e.Message;
+                    cr.IsValid = false;
+                }
+            }
+            return cr;
+        }
 
-        public static CalcResult<T> operator +(CalcResult<T> x, CalcResult<T> y) => x.Add(y);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator +(CalcResult<T> cr, T v)
+        {
+            if (cr.IsValid)
+            {
+                try
+                {
+                    cr._value = Arithmetic<T>.Add(cr._value, v);
+                }
+                catch (Exception e)
+                {
+                    cr.Message = e.Message;
+                    cr.IsValid = false;
+                }
+            }
+            return cr;
+        }
 
-        public static CalcResult<T> operator -(CalcResult<T> x, CalcResult<T> y) => x.Subtract(y);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator -(CalcResult<T> cr, T v)
+        {
+            if (cr.IsValid)
+            {
+                try
+                {
+                    cr._value = Arithmetic<T>.Subtract(cr._value, v);
+                }
+                catch (Exception e)
+                {
+                    cr.Message = e.Message;
+                    cr.IsValid = false;
+                }
+            }
+            return cr;
+        }
 
-        public static CalcResult<T> operator *(CalcResult<T> x, CalcResult<T> y) => x.Multiply(y);
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator *(CalcResult<T> cr, T v)
+        {
+            if (cr.IsValid)
+            {
+                try
+                {
+                    cr._value = Arithmetic<T>.Multiply(cr._value, v);
+                }
+                catch (Exception e)
+                {
+                    cr.Message = e.Message;
+                    cr.IsValid = false;
+                }
+            }
+            return cr;
+        }
 
-        public static CalcResult<T> operator /(CalcResult<T> x, CalcResult<T> y) => x.Divide(y);
-        #endregion
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator /(CalcResult<T> cr, T v)
+        {
+            if (cr.IsValid)
+            {
+                try
+                {
+                    cr._value = Arithmetic<T>.Divide(cr._value, v);
+                }
+                catch (Exception e)
+                {
+                    cr.Message = e.Message;
+                    cr.IsValid = false;
+                }
+            }
+            return cr;
+        }
 
-        //public static explicit operator CalcResult<T>(T value)
-        //{
-        //    return new CalcResult<T>(value);
-        //}
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator +(CalcResult<T> a, CalcResult<T> b)
+        {
+            if (a.IsValid)
+            {
+                if (b.IsValid)
+                {
+                    try
+                    {
+                        a._value = Arithmetic<T>.Add(a._value, b._value);
+                    }
+                    catch (Exception e)
+                    {
+                        a.Message = e.Message;
+                        a.IsValid = false;
+                    }
+                }
+                else
+                {
+                    return b;
+                }
+            }
+            return a;
+        }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator -(CalcResult<T> a, CalcResult<T> b)
+        {
+            if (a.IsValid)
+            {
+                if (b.IsValid)
+                {
+                    try
+                    {
+                        a._value = Arithmetic<T>.Subtract(a._value, b._value);
+                    }
+                    catch (Exception e)
+                    {
+                        a.Message = e.Message;
+                        a.IsValid = false;
+                    }
+                }
+                else
+                {
+                    return b;
+                }
+            }
+            return a;
+        }
 
-        public static implicit operator T(CalcResult<T> v)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator *(CalcResult<T> a, CalcResult<T> b)
         {
-            return v.Value;
+            if (a.IsValid)
+            {
+                if (b.IsValid)
+                {
+                    try
+                    {
+                        a._value = Arithmetic<T>.Multiply(a._value, b._value);
+                    }
+                    catch (Exception e)
+                    {
+                        a.Message = e.Message;
+                        b.IsValid = false;
+                    }
+                }
+                else
+                {
+                    return b;
+                }
+            }
+            return a;
         }
 
-        public static implicit operator CalcResult<T>(T v)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static CalcResult<T> operator /(CalcResult<T> a, CalcResult<T> b)
         {
-            return new CalcResult<T>(v);
+            if (a.IsValid)
+            {
+                if (b.IsValid)
+                {
+                    try
+                    {
+                        a._value = Arithmetic<T>.Divide(a._value, b._value);
+                    }
+                    catch (Exception e)
+                    {
+                        a.Message = e.Message;
+                        a.IsValid = false;
+                    }
+                }
+                else
+                {
+                    return b;
+                }
+            }
+            return a;
         }
+
+        #endregion
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator bool(CalcResult<T> v) => v.IsValid;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator CalcResult<T>(T v) => new CalcResult<T>(v);
     }
-}
+}
\ No newline at end of file