.NET Inside Out Part 30 – Conditional types in C#

This is the thirtieth part of the .NET Inside Out series. For your convenience you can find other parts in the table of contents in Part 1 – Virtual and non-virtual calls in C#

TypeScript has a very nice feature called conditional types. Can we mimic something like this in C#? Let’s say that we have one API endpoint that should return different output depending on the type of the input.

We can start with the following code:

using System;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine(GetForInput(new ScenarioAInput()).GetType());
		Console.WriteLine(GetForInput(new ScenarioBInput()).GetType());
	}
	
	public static Output<T> GetForInput<T>(Input<T> input) where T: Scenario{
		if(typeof(Input<ScenarioA>).IsAssignableFrom(input.GetType())){
			return (Output<T>)(object)GetForInputA((ScenarioAInput)(object)input);
		}
		if(typeof(Input<ScenarioB>).IsAssignableFrom(input.GetType())){
			return (Output<T>)(object)GetForInputB((ScenarioBInput)(object)input);
		}
		
		throw new Exception("Bang!");
	}
	
	public static ScenarioAOutput GetForInputA(ScenarioAInput input){
		return new ScenarioAOutput();
	}
	
	public static ScenarioBOutput GetForInputB(ScenarioBInput input){
		return new ScenarioBOutput();
	}
}

public abstract class Scenario {
}

public class ScenarioA : Scenario{
}

public class ScenarioB: Scenario{
}

public abstract class Input<T> where T: Scenario{
}

public class ScenarioAInput : Input<ScenarioA> {
}

public class ScenarioBInput : Input<ScenarioB> {
}

public abstract class Output<T> where T: Scenario{
}

public class ScenarioAOutput: Output<ScenarioA> {
}

public class ScenarioBOutput: Output<ScenarioB>{
}

using System;

public class Program

{

public static void Main()

{

Console.WriteLine(GetForInput(new ScenarioAInput()).GetType());

Console.WriteLine(GetForInput(new ScenarioBInput()).GetType());

}

public static Output<T> GetForInput<T>(Input<T> input) where T: Scenario{

if(typeof(Input<ScenarioA>).IsAssignableFrom(input.GetType())){

return (Output<T>)(object)GetForInputA((ScenarioAInput)(object)input);

}

if(typeof(Input<ScenarioB>).IsAssignableFrom(input.GetType())){

return (Output<T>)(object)GetForInputB((ScenarioBInput)(object)input);

}

throw new Exception("Bang!");

}

public static ScenarioAOutput GetForInputA(ScenarioAInput input){

return new ScenarioAOutput();

}

public static ScenarioBOutput GetForInputB(ScenarioBInput input){

return new ScenarioBOutput();

}

public abstract class Scenario {

}

public class ScenarioA : Scenario{

}

public class ScenarioB: Scenario{

}

public abstract class Input<T> where T: Scenario{

}

public class ScenarioAInput : Input<ScenarioA> {

}

public class ScenarioBInput : Input<ScenarioB> {

}

public abstract class Output<T> where T: Scenario{

}

public class ScenarioAOutput: Output<ScenarioA> {

}

public class ScenarioBOutput: Output<ScenarioB>{

}

This works but is a little bit cumbersome. When we need to add new implementation, we need to add another if condition. Can we do better? Well, a little:

using System;
using System.Linq;
using System.Collections.Generic;
					
public class Program
{
	public static void Main()
	{
		Console.WriteLine(GetForInput(new ScenarioAInput()).GetType());
		Console.WriteLine(GetForInput(new ScenarioBInput()).GetType());
	}
	
	public static Output<T> GetForInput<T>(Input<T> input) where T: Scenario<T> {
		List<Scenario> implementations = new List<Scenario>(){
			new ScenarioA(),
			new ScenarioB()
		};
		
		foreach(var implementation in implementations){
			if(implementation.GetType().GetInterfaces().First().GetGenericArguments().First() == typeof(T)){
				return ((Scenario<T>)implementation).Calculate(input);
			}
		}
		
		throw new Exception("Didn't work");
	}
}

public interface Scenario{
}

public interface Scenario<T> : Scenario where T: Scenario<T> {
	Output<T> Calculate(Input<T> input);
}

public class ScenarioA : Scenario<ScenarioA> {
	public Output<ScenarioA> Calculate(Input<ScenarioA> input){
		return new ScenarioAOutput();
	}
}

public class ScenarioB: Scenario<ScenarioB> {
	public Output<ScenarioB> Calculate(Input<ScenarioB> input){
		return new ScenarioBOutput();
	}
}

public abstract class Input<T> where T: Scenario<T> {
}

public class ScenarioAInput : Input<ScenarioA> {
}

public class ScenarioBInput : Input<ScenarioB> {
}

public abstract class Output<T> where T: Scenario<T> {
}

public class ScenarioAOutput: Output<ScenarioA> {
}

public class ScenarioBOutput: Output<ScenarioB> {
}

using System;

using System.Linq;

using System.Collections.Generic;

public class Program

{

public static void Main()

{

Console.WriteLine(GetForInput(new ScenarioAInput()).GetType());

Console.WriteLine(GetForInput(new ScenarioBInput()).GetType());

}

public static Output<T> GetForInput<T>(Input<T> input) where T: Scenario<T> {

List<Scenario> implementations = new List<Scenario>(){

new ScenarioA(),

new ScenarioB()

};

foreach(var implementation in implementations){

if(implementation.GetType().GetInterfaces().First().GetGenericArguments().First() == typeof(T)){

return ((Scenario<T>)implementation).Calculate(input);

}

throw new Exception("Didn't work");

}

public interface Scenario{

}

public interface Scenario<T> : Scenario where T: Scenario<T> {

Output<T> Calculate(Input<T> input);

}

public class ScenarioA : Scenario<ScenarioA> {

public Output<ScenarioA> Calculate(Input<ScenarioA> input){

return new ScenarioAOutput();

}

public class ScenarioB: Scenario<ScenarioB> {

public Output<ScenarioB> Calculate(Input<ScenarioB> input){

return new ScenarioBOutput();

}

public abstract class Input<T> where T: Scenario<T> {

}

public class ScenarioAInput : Input<ScenarioA> {

}

public class ScenarioBInput : Input<ScenarioB> {

}

public abstract class Output<T> where T: Scenario<T> {

}

public class ScenarioAOutput: Output<ScenarioA> {

}

public class ScenarioBOutput: Output<ScenarioB> {

}

Now adding new type requires adding new instance to the collection. However, this time we can scan all the types and crate them on the fly as needed with DI or whatever other mechanism.