GH-37730: [C#] throw OverflowException in DecimalUtility if fractionalPart is too large

csharp/src/Apache.Arrow/DecimalUtility.cs

@@ -50,10 +50,21 @@ internal static decimal GetDecimal(in ArrowBuffer valueBuffer, int index, int sc
             {
                 BigInteger scaleBy = BigInteger.Pow(10, scale);
                 BigInteger integerPart = BigInteger.DivRem(integerValue, scaleBy, out BigInteger fractionalPart);
-                if (integerPart > _maxDecimal || integerPart < _minDecimal) // decimal overflow, not much we can do here - C# needs a BigDecimal
+
+                // decimal overflow, not much we can do here - C# needs a BigDecimal
+                if (integerPart > _maxDecimal)
+                {
+                    throw new OverflowException($"Value: {integerPart} of {integerValue} is too big be represented as a decimal");
+                }
+                else if (integerPart < _minDecimal) 
                 {
-                    throw new OverflowException($"Value: {integerPart} too big or too small to be represented as a decimal");
+                    throw new OverflowException($"Value: {integerPart} of {integerValue} is too small be represented as a decimal");
                 }
+                else if (fractionalPart > _maxDecimal || fractionalPart < _minDecimal)
+                {
+                    throw new OverflowException($"Value: {fractionalPart} of {integerValue} is too precise be represented as a decimal");
+                }
+
                 return (decimal)integerPart + DivideByScale(fractionalPart, scale);
             }
             else

csharp/test/Apache.Arrow.Tests/DecimalUtilityTests.cs

@@ -46,6 +46,25 @@ public void HasExpectedResultOrThrows(decimal d, int precision , int scale, bool
                     Assert.Equal(d, result.GetValue(0));
                 }
             }
+
+            [Theory]
+            [InlineData(4.56, 38, 9, false)]
+            [InlineData(7.89, 76, 38, true)]
+            public void Decimal256HasExpectedResultOrThrows(decimal d, int precision, int scale, bool shouldThrow)
+            {
+                var builder = new Decimal256Array.Builder(new Decimal256Type(precision, scale));
+                builder.Append(d);
+                Decimal256Array result = builder.Build(new TestMemoryAllocator()); ;
+
+                if (shouldThrow)
+                {
+                    Assert.Throws<OverflowException>(() => result.GetValue(0));
+                }
+                else
+                {
+                    Assert.Equal(d, result.GetValue(0));
+                }
+            }
         }
     }
 }