diff --git a/src/bindings/mono/eina_mono/eina_value.cs b/src/bindings/mono/eina_mono/eina_value.cs
index 9ff4de5b13..be84e4adff 100644
--- a/src/bindings/mono/eina_mono/eina_value.cs
+++ b/src/bindings/mono/eina_mono/eina_value.cs
@@ -804,6 +804,204 @@ public class Value : IDisposable, IComparable<Value>, IEquatable<Value>
         return new Value(v);
     }
 
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(byte x)
+    {
+        var v = new Eina.Value(ValueType.Byte);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator byte(Value v)
+    {
+        byte b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(sbyte x)
+    {
+        var v = new Eina.Value(ValueType.SByte);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator sbyte(Value v)
+    {
+        sbyte b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(short x)
+    {
+        var v = new Eina.Value(ValueType.Short);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator short(Value v)
+    {
+        short b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(ushort x)
+    {
+        var v = new Eina.Value(ValueType.UShort);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator ushort(Value v)
+    {
+        ushort b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(int x)
+    {
+        var v = new Eina.Value(ValueType.Int32);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator int(Value v)
+    {
+        int b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(uint x)
+    {
+        var v = new Eina.Value(ValueType.UInt32);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator uint(Value v)
+    {
+        uint b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(long x)
+    {
+        var v = new Eina.Value(ValueType.Long);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator long(Value v)
+    {
+        long b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(ulong x)
+    {
+        var v = new Eina.Value(ValueType.ULong);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator ulong(Value v)
+    {
+        ulong b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(float x)
+    {
+        var v = new Eina.Value(ValueType.Float);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator float(Value v)
+    {
+        float b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(double x)
+    {
+        var v = new Eina.Value(ValueType.Double);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator double(Value v)
+    {
+        double b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator Value(string x)
+    {
+        var v = new Eina.Value(ValueType.String);
+        if (!v.Set(x))
+            throw new InvalidOperationException("Couldn't set value.");
+        return v;
+    }
+
+    /// <summary>Implicit conversion.</summary>
+    public static implicit operator string(Value v)
+    {
+        string b;
+        if (!v.Get(out b))
+            throw new InvalidOperationException("Couldn't get value.");
+        return b;
+    }
+
     /// <summary>Creates an Value instance from a given array description.</summary>
     private static Value FromArrayDesc(Eina.EinaNative.Value_Array arrayDesc)
     {
diff --git a/src/tests/efl_mono/ValueEolian.cs b/src/tests/efl_mono/ValueEolian.cs
index 78da29087a..4d33dfacde 100644
--- a/src/tests/efl_mono/ValueEolian.cs
+++ b/src/tests/efl_mono/ValueEolian.cs
@@ -116,6 +116,43 @@ public static class TestEinaValueEolian {
             Test.AssertEquals(val, obj.value);
         }
     }
+
+    public static void TestEolianEinaValueImplicitOperators()
+    {
+        var obj = new Dummy.TestObject();
+        int payload = 1999;
+        obj.SetValue(payload);
+
+        var expected = new Eina.Value(1999);
+        var received = new Eina.Value(Eina.ValueType.String);
+
+        obj.OutValue(out received);
+        Test.AssertEquals(expected, received);
+        Test.AssertEquals(Eina.ValueType.Int32, received.GetValueType());
+
+        int i = received;
+        Test.AssertEquals(i, 1999);
+
+        expected = new Eina.Value("Hallo");
+        obj.SetValue("Hallo");
+
+        obj.OutValue(out received);
+        Test.AssertEquals(expected, received);
+        Test.AssertEquals(Eina.ValueType.String, received.GetValueType());
+
+        string s = received;
+        Test.AssertEquals(s, "Hallo");
+
+        // Casting
+        expected = new Eina.Value((double)15);
+        obj.SetValue((double)15);
+
+        obj.OutValue(out received);
+        Test.AssertEquals(expected, received);
+        Test.AssertEquals(Eina.ValueType.Double, received.GetValueType());
+
+
+    }
 }
 #pragma warning restore 1591
 }