C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Reflection;

// (Not working) solution with generics. Problem: V1Manager.Handle is always called with type parameter being V1AbstractEvent

public abstract class V1AbstractEvent
{
	public void Trigger()
	{
		new V1Manager().Handle(this);
	}
}

public class V1ConcreteEvent : V1AbstractEvent {}

public class V1Manager
{
	public void Handle<TEvent>(TEvent evt)
		where TEvent : V1AbstractEvent
	{
		Console.WriteLine("TEvent type: " + typeof(TEvent));
		dynamic writer = new V1Writer();
		writer.Write(evt);
	}
}

public class V1Writer
{
	public void Write(V1AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V1ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}

// (Not working) solution with base class parameter. Problem: Dynamic invocation takes the defined parameter type

public abstract class V2AbstractEvent
{
	public void Trigger()
	{
		new V2Manager().Handle(this);
	}
}

public class V2ConcreteEvent : V2AbstractEvent {}

public class V2Manager
{
	public void Handle(V2AbstractEvent evt)
	{
		Console.WriteLine("evt type: " + evt.GetType());
		dynamic writer = new V2Writer();
		writer.Write(evt);
	}
}

public class V2Writer
{
	public void Write(V2AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V2ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}

// Solution with generics and each event having an own triggering implementation. Problem: Code repetition

public abstract class V3AbstractEvent
{
	public void Trigger()
	{
		this.TriggerInternal(new V3Manager());
	}
	
	protected abstract void TriggerInternal(V3Manager manager);
}

public class V3ConcreteEvent : V3AbstractEvent
{
	protected override void TriggerInternal(V3Manager manager)
	{
		manager.Handle(this);
	}
}

public class V3Manager
{
	public void Handle<TEvent>(TEvent evt)
		where TEvent : V3AbstractEvent
	{
		Console.WriteLine("TEvent type: " + typeof(TEvent));
		dynamic writer = new V3Writer();
		writer.Write(evt);
	}
}

public class V3Writer
{
	public void Write(V3AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V3ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}

// Solution with casting of event to dynamic type as well. Problem: Run-time check only and potentially slow

public abstract class V4AbstractEvent
{
	public void Trigger()
	{
		new V4Manager().Handle(this);
	}
}

public class V4ConcreteEvent : V4AbstractEvent {}

public class V4Manager
{
	public void Handle<TEvent>(TEvent evt)
		where TEvent : V4AbstractEvent
	{
		Console.WriteLine("TEvent type: " + typeof(TEvent));
		dynamic writer = new V4Writer();
		writer.Write((dynamic)evt);
	}
}

public class V4Writer
{
	public void Write(V4AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V4ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}

// Solution with Reflection-invocation of generic Handle method. Problem: Potentially slow

public abstract class V5AbstractEvent
{
	public void Trigger()
	{
		var manager = new V5Manager();
		var method = typeof(V5Manager).GetMethod("Handle");
		var genericMethod = method.MakeGenericMethod(this.GetType());
		genericMethod.Invoke(manager, new[] { this });
	}
}

public class V5ConcreteEvent : V5AbstractEvent {}

public class V5Manager
{
	public void Handle<TEvent>(TEvent evt)
		where TEvent : V5AbstractEvent
	{
		Console.WriteLine("TEvent type: " + typeof(TEvent));
		dynamic writer = new V5Writer();
		writer.Write(evt);
	}
}

public class V5Writer
{
	public void Write(V5AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V5ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}

// Solution with explicit specification of the type on triggering. Problem: Redundant info in trigger invocation, only with run-time checks

public abstract class V6AbstractEvent
{
	public void Trigger<TEvent>()
		where TEvent : V6AbstractEvent
	{
		if (typeof(TEvent) != this.GetType())
		{
			throw new ArgumentException("Wrong type");
		}
			
		new V6Manager().Handle<TEvent>((TEvent)this);
	}
}

public class V6ConcreteEvent : V6AbstractEvent {}

public class V6Manager
{
	public void Handle<TEvent>(TEvent evt)
		where TEvent : V6AbstractEvent
	{
		Console.WriteLine("TEvent type: " + typeof(TEvent));
		dynamic writer = new V6Writer();
		writer.Write(evt);
	}
}

public class V6Writer
{
	public void Write(V6AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V6ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}

// Solution with casting of event to dynamic type as well (upfront). Problem: Run-time check only and potentially slow

public abstract class V7AbstractEvent
{
	public void Trigger()
	{
		new V7Manager().Handle((dynamic)this);
	}
}

public class V7ConcreteEvent : V7AbstractEvent {}

public class V7Manager
{
	public void Handle<TEvent>(TEvent evt)
		where TEvent : V7AbstractEvent
	{
		Console.WriteLine("TEvent type: " + typeof(TEvent));
		dynamic writer = new V7Writer();
		writer.Write(evt);
	}
}

public class V7Writer
{
	public void Write(V7AbstractEvent evt)
	{
		Console.WriteLine("AbstractEvent");
	}
	
	public void Write(V7ConcreteEvent evt)
	{
		Console.WriteLine("ConcreteEvent");
	}
}


// Runner

public class Program
{
	public static void Main()
	{
		Console.WriteLine("V1");
		new V1ConcreteEvent().Trigger();
		Console.WriteLine("V2");
		new V2ConcreteEvent().Trigger();
		Console.WriteLine("V3");
		new V3ConcreteEvent().Trigger();
		Console.WriteLine("V4");
		new V4ConcreteEvent().Trigger();
		Console.WriteLine("V5");
		new V5ConcreteEvent().Trigger();
		Console.WriteLine("V6");
		new V6ConcreteEvent().Trigger<V6ConcreteEvent>();
		Console.WriteLine("V7");
		new V7ConcreteEvent().Trigger();
	}
}

​x
 
using System;
using System.Reflection;
​
// (Not working) solution with generics. Problem: V1Manager.Handle is always called with type parameter being V1AbstractEvent
​
public abstract class V1AbstractEvent
{
    public void Trigger()
    {
        new V1Manager().Handle(this);
    }
}
​
public class V1ConcreteEvent : V1AbstractEvent {}
​
public class V1Manager
{
    public void Handle<TEvent>(TEvent evt)
        where TEvent : V1AbstractEvent
    {
        Console.WriteLine("TEvent type: " + typeof(TEvent));
        dynamic writer = new V1Writer();
        writer.Write(evt);
    }
}
​
public class V1Writer
{
    public void Write(V1AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V1ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
// (Not working) solution with base class parameter. Problem: Dynamic invocation takes the defined parameter type
​
public abstract class V2AbstractEvent
{
    public void Trigger()
    {
        new V2Manager().Handle(this);
    }
}
​
public class V2ConcreteEvent : V2AbstractEvent {}
​
public class V2Manager
{
    public void Handle(V2AbstractEvent evt)
    {
        Console.WriteLine("evt type: " + evt.GetType());
        dynamic writer = new V2Writer();
        writer.Write(evt);
    }
}
​
public class V2Writer
{
    public void Write(V2AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V2ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
// Solution with generics and each event having an own triggering implementation. Problem: Code repetition
​
public abstract class V3AbstractEvent
{
    public void Trigger()
    {
        this.TriggerInternal(new V3Manager());
    }
    
    protected abstract void TriggerInternal(V3Manager manager);
}
​
public class V3ConcreteEvent : V3AbstractEvent
{
    protected override void TriggerInternal(V3Manager manager)
    {
        manager.Handle(this);
    }
}
​
public class V3Manager
{
    public void Handle<TEvent>(TEvent evt)
        where TEvent : V3AbstractEvent
    {
        Console.WriteLine("TEvent type: " + typeof(TEvent));
        dynamic writer = new V3Writer();
        writer.Write(evt);
    }
}
​
public class V3Writer
{
    public void Write(V3AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V3ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
// Solution with casting of event to dynamic type as well. Problem: Run-time check only and potentially slow
​
public abstract class V4AbstractEvent
{
    public void Trigger()
    {
        new V4Manager().Handle(this);
    }
}
​
public class V4ConcreteEvent : V4AbstractEvent {}
​
public class V4Manager
{
    public void Handle<TEvent>(TEvent evt)
        where TEvent : V4AbstractEvent
    {
        Console.WriteLine("TEvent type: " + typeof(TEvent));
        dynamic writer = new V4Writer();
        writer.Write((dynamic)evt);
    }
}
​
public class V4Writer
{
    public void Write(V4AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V4ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
// Solution with Reflection-invocation of generic Handle method. Problem: Potentially slow
​
public abstract class V5AbstractEvent
{
    public void Trigger()
    {
        var manager = new V5Manager();
        var method = typeof(V5Manager).GetMethod("Handle");
        var genericMethod = method.MakeGenericMethod(this.GetType());
        genericMethod.Invoke(manager, new[] { this });
    }
}
​
public class V5ConcreteEvent : V5AbstractEvent {}
​
public class V5Manager
{
    public void Handle<TEvent>(TEvent evt)
        where TEvent : V5AbstractEvent
    {
        Console.WriteLine("TEvent type: " + typeof(TEvent));
        dynamic writer = new V5Writer();
        writer.Write(evt);
    }
}
​
public class V5Writer
{
    public void Write(V5AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V5ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
// Solution with explicit specification of the type on triggering. Problem: Redundant info in trigger invocation, only with run-time checks
​
public abstract class V6AbstractEvent
{
    public void Trigger<TEvent>()
        where TEvent : V6AbstractEvent
    {
        if (typeof(TEvent) != this.GetType())
        {
            throw new ArgumentException("Wrong type");
        }
            
        new V6Manager().Handle<TEvent>((TEvent)this);
    }
}
​
public class V6ConcreteEvent : V6AbstractEvent {}
​
public class V6Manager
{
    public void Handle<TEvent>(TEvent evt)
        where TEvent : V6AbstractEvent
    {
        Console.WriteLine("TEvent type: " + typeof(TEvent));
        dynamic writer = new V6Writer();
        writer.Write(evt);
    }
}
​
public class V6Writer
{
    public void Write(V6AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V6ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
// Solution with casting of event to dynamic type as well (upfront). Problem: Run-time check only and potentially slow
​
public abstract class V7AbstractEvent
{
    public void Trigger()
    {
        new V7Manager().Handle((dynamic)this);
    }
}
​
public class V7ConcreteEvent : V7AbstractEvent {}
​
public class V7Manager
{
    public void Handle<TEvent>(TEvent evt)
        where TEvent : V7AbstractEvent
    {
        Console.WriteLine("TEvent type: " + typeof(TEvent));
        dynamic writer = new V7Writer();
        writer.Write(evt);
    }
}
​
public class V7Writer
{
    public void Write(V7AbstractEvent evt)
    {
        Console.WriteLine("AbstractEvent");
    }
    
    public void Write(V7ConcreteEvent evt)
    {
        Console.WriteLine("ConcreteEvent");
    }
}
​
​
// Runner
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("V1");
        new V1ConcreteEvent().Trigger();
        Console.WriteLine("V2");
        new V2ConcreteEvent().Trigger();
        Console.WriteLine("V3");
        new V3ConcreteEvent().Trigger();
        Console.WriteLine("V4");
        new V4ConcreteEvent().Trigger();
        Console.WriteLine("V5");
        new V5ConcreteEvent().Trigger();
        Console.WriteLine("V6");
        new V6ConcreteEvent().Trigger<V6ConcreteEvent>();
        Console.WriteLine("V7");
        new V7ConcreteEvent().Trigger();
    }
}

Compilation error (line 1, col 7): The type or namespace name 'UnityEngine' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 2, col 7): The type or namespace name 'UnityEngine' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 6, col 28): The type or namespace name 'InteractPanelBase' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 6, col 47): The type or namespace name 'IMessageBox' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 9, col 10): The type or namespace name 'Button' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 12, col 10): The type or namespace name 'Text' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 8, col 4): The type or namespace name 'Header' could not be found (are you missing a using directive or an assembly reference?)
Compilation error (line 8, col 4): The type or namespace name 'HeaderAttribute' could not be found (are you missing a using directive or an assembly reference?)

Last Run:	2:02:46 pm
Compile:	0s
Execute:	0.275s
Memory:	0b
CPU:	0s

View IL Code