C#

using System;

namespace FloatingPointConversion
{
  public class Program
  {
    public static void Main(string[] args)
    {
      decimal decimalValue = 123.456M;
      double doubleValue = 123.456D;
      float floatValue = 123.456F;

      Console.WriteLine($"{nameof(floatValue)} = {floatValue}");
      // floatValue = 123.456

      Console.WriteLine($"{nameof(decimalValue)} = {decimalValue}");
      // decimalValue = 123.456

      Console.WriteLine($"{nameof(doubleValue)} = {doubleValue}");
      // doubleValue = 123.456

      Console.WriteLine($"(float){nameof(decimalValue)} = {(float)decimalValue}");
      // (float)decimalValue = 123.456

      Console.WriteLine($"(double){nameof(decimalValue)} = {(double)decimalValue}");
      // (double)decimalValue = 123.456

      Console.WriteLine($"(decimal){nameof(doubleValue)} = {(decimal)doubleValue}");
      // (decimal)doubleValue = 123.456

      Console.WriteLine($"(float){nameof(doubleValue)} = {(float)doubleValue}");
      // (float)doubleValue = 123.456

      Console.WriteLine($"(decimal){nameof(floatValue)} = {(decimal)floatValue}");
      // (decimal)floatValue = 123.456

      Console.WriteLine($"(double){nameof(floatValue)} = {(double)floatValue}");
      // (double)floatValue = 123.456001281738

      Console.WriteLine($"(double)((decimal){nameof(floatValue)}) = {(double)((decimal)floatValue)}");
      // (double)((decimal)floatValue) = 123.456
    }
  }
}

using System;

namespace FloatingPointConversion
{
  public class Program
  {
    private static readonly decimal[] Divisors = new decimal[] { 1, 10, 100, 1000, 10000 };

    private static readonly string[] UnexpectedLabels = new string[]
    {
      "decimal", "double", "float", "decimal->double", "decimal->float", "double->decimal",
      "double->float", "float->decimal", "float->double"
    };

    private static readonly int[] UnexpectedCounts = new int[UnexpectedLabels.Length];
    private const int MaximumSixDigitNumber = 999999;
    private const int NumberOfAttempts = 1000000;

    public static void Main(string[] args)
    {
      RandomTest();
      for (int index = 0; index < UnexpectedLabels.Length; index++)
        Console.WriteLine($"{UnexpectedLabels[index]}: {UnexpectedCounts[index]}");
    }

    private static void RandomTest()
    {
      var random = new Random();

      for (int attempt = 0; attempt < NumberOfAttempts; attempt++)
      {
        int intValue = random.Next(MaximumSixDigitNumber + 1);
        int shift = random.Next(0, Divisors.Length);

        string idealText = GetIdealText(intValue, shift);

        decimal decimalValue = intValue / Divisors[shift];
        float floatValue = intValue / (float)Divisors[shift];
        double doubleValue = intValue / (double)Divisors[shift];

        if (decimalValue.ToString() != idealText)
          UnexpectedCounts[0]++;
        if (doubleValue.ToString() != idealText)
          UnexpectedCounts[1]++;
        if (floatValue.ToString() != idealText)
          UnexpectedCounts[2]++;
        if (((double)decimalValue).ToString() != idealText)
          UnexpectedCounts[3]++;
        if (((float)decimalValue).ToString() != idealText)
          UnexpectedCounts[4]++;
        if (((decimal)doubleValue).ToString() != idealText)
          UnexpectedCounts[5]++;
        if (((float)doubleValue).ToString() != idealText)
          UnexpectedCounts[6]++;
        if (((decimal)floatValue).ToString() != idealText)
          UnexpectedCounts[7]++;
        if (((double)floatValue).ToString() != idealText)
          UnexpectedCounts[8]++;
      }
    }

    private static string GetIdealText(int intValue, int shift)
    {
      string text = intValue.ToString();
      if (shift == 0)
        return text;

      return TrimTrailingZeros(text = shift >= text.Length ?
        "0." + text.PadLeft(shift, '0') : text.Insert(text.Length - shift, "."));
    }

    private static string TrimTrailingZeros(string text)
    {
      int length = text.Length;
      while(text[length - 1] == '0')
        length--;

      if (text[length - 1] == '.')
        length--;

      return length < text.Length ? text.Substring(0, length) : text;
    }
  }
}

interface IMyFunctionInterface
{
	void NeededFunction(object state);
}

internal abstract class MyBaseImplementation : IMyFunctionInterface
{
	internal MyRelevantProperty { get; protected set; }
	public void NeededFunction(object state) 
	{ 
		//defined here only to satisfy interface requirements... 
	  	//want to force this to be implemented in each subclass rather than here
	}
}

internal class Implementation1 : MyBaseImplementation
{
	public void NeededFunction(object state)... // want to define this here instead of in base class
}

{1, 2, 2, 4, 2, 2, 2, 9} with "bomb" number 4 and power: 3

{2, 2, 2, 9}.