How to define two possible data type for property

Question

I am trying to define an operator overloads in C# for 2 classes: Fraction and BasicFraction. On the outside, they act the same, but internally Fraction uses PrimeFactorization (stores number as a list of prime factors) and BasicFraction uses int for storing the nominator and denominator.

They would follow this interface (if I use JSDoc type definitions):

public interface IFraction
{
  public (int|Primefactoriztion) a; // nominator
  public (int|Primefactoriztion) b; // denominator
}

But since I can't do that like this, is there a simple way to use Fraction and BasicFraction interchangeably?
I can define all operator overloads for evaluating interactions between int and PrimeFactorization. However, I don't know how to tell C# to accept both to be passed to methods.

Tl;dr: how to make one property allow 2 data types?

Notes:

• I am new to advanced C# (I know static typing and basic OOP, but nothing more). I am coming from JS and Python background.
• I know they are probably good libraries with this functionality. I am writing this in order to learn C#, not for production.

Edit: Currently, PrimeFactorization stores factors and their power in Dictionary<int, BasicFraction> (I would use Fraction, but it causes recursion; this is basically the only usage of BasicFraction).

Answer 1

You want a discriminated union type. C# does not support them natively as a first-class language feature but you can hack-it using OneOf: https://github.com/mcintyre321/OneOf

So you would end-up with:

public interface IFraction
{
  public OneOf< int, Primefactoriztion > a; // nominator
  public OneOf< int, Primefactoriztion > b; // denominator
}

but it's still a code-smell. I think you need to reconsider your entire approach. Also, using interfaces to represent values probably isn't a good idea (due to all the heap-allocation), especially because your a and b members appear to be mutable.

---

A better idea is to change your Primefactoriztion type (which I hope and assume is a struct, not a class) to support implicit conversion from int and some member for explicit conversion to int if the operation is unsafe (e.g. if the value is not an integer):

struct Primefactoriztion
{
    public static implicit operator int(Primefactoriztion self)
    {
        return ...
    }
}

That way you can safely eliminate the OneOf<int and use just Primefactoriztion:

public interface IFraction
{
  public Primefactoriztion a; // nominator
  public Primefactoriztion b; // denominator
}

Answer 2

What you have in mind is called discriminated union and is not available as language feature in C#.

I would use a hybrid approach where a fraction would contain nominator and denominator as int plus prime factor lists as read-only properties. You could initialize the fraction with either ints or prime factor lists through two constructors. The missing entries would be calculated lazily to minimize the calculation overhead.

Making the properties read-only increases the robustness of the code. Especially if you are using structs. See Mutating readonly structs (Eric Lippert's blog: Fabulous adventures in coding). But note that the struct is still mutable because of the lazy evaluation.

public struct Fraction
{
    public Fraction(int nominator, int denominator)
    {
        _nominator = nominator;
        _denominator = denominator;
        _nominatorPrimeFactors = null;
        _denominatorPrimeFactors = null;
    }

    public Fraction(IList<int> nominatorPrimeFactors, IList<int> denominatorPrimeFactors)
    {
        if (nominatorPrimeFactors == null || nominatorPrimeFactors.Count == 0) {
            throw new ArgumentNullException(
                $"{nameof(nominatorPrimeFactors)} must be a non-null, non-empty list");
        }
        if (denominatorPrimeFactors == null || denominatorPrimeFactors.Count == 0) {
            throw new ArgumentNullException(
                $"{nameof(denominatorPrimeFactors)} must be a non-null, non-empty list");
        }
        _nominator = null;
        _denominator = null;
        _nominatorPrimeFactors = nominatorPrimeFactors;
        _denominatorPrimeFactors = denominatorPrimeFactors;
    }

    private int? _nominator;
    public int Nominator
    {
        get {
            if (_nominator == null) {
                _nominator = _nominatorPrimeFactors.Aggregate(1, (x, y) => x * y);
            }
            return _nominator.Value;
        }
    }

    private int? _denominator;
    public int Denominator
    {
        get {
            if (_denominator == null) {
                _denominator = _denominatorPrimeFactors.Aggregate(1, (x, y) => x * y);
            }
            return _denominator.Value;
        }
    }

    private IList<int> _nominatorPrimeFactors;
    public IList<int> NominatorPrimeFactors
    {
        get {
            if (_nominatorPrimeFactors == null) {
                _nominatorPrimeFactors = Factorize(Nominator);
            }
            return _nominatorPrimeFactors;
        }
    }

    private IList<int> _denominatorPrimeFactors;
    public IList<int> DenominatorPrimeFactors
    {
        get {
            if (_denominatorPrimeFactors == null) {
                _denominatorPrimeFactors = Factorize(Denominator);
            }
            return _denominatorPrimeFactors;
        }
    }

    private static List<int> Factorize(int number)
    {
        var result = new List<int>();

        while (number % 2 == 0) {
            result.Add(2);
            number /= 2;
        }

        int factor = 3;
        while (factor * factor <= number) {
            if (number % factor == 0) {
                result.Add(factor);
                number /= factor;
            } else {
                factor += 2;
            }
        }
        if (number > 1) result.Add(number);

        return result;
    }

    public override string ToString()
    {
        if (_nominatorPrimeFactors == null && _denominatorPrimeFactors == null) {
            return $"{_nominator}/{_denominator}";
        }
        string npf = ListToString(_nominatorPrimeFactors);
        string dpf = ListToString(_denominatorPrimeFactors);

        if (_nominator == null && _denominator == null) {
            return $"({npf}) / ({dpf})";
        }
        return $"{_nominator}/{_denominator}, ({npf}) / ({dpf})";


        static string ListToString(IList<int> primeFactors)
        {
            if (primeFactors == null) {
                return null;
            }
            return String.Join(" * ", primeFactors.Select(i => i.ToString()));
        }
    }
}

Note that declaring the prime factor lists a IList<int> allows you to initialize the fraction with either int[] or List<int>.

But it is worth considering whether the prime factors really need to be stored. Isn't it enough to calculate them when required by some calculation?