Your program has two delegate types named ErrorEventHandler. One declared in the upper snippet, another declared in the lower snippet. They have distinct names and probably don't even live in the same namespace, but that doesn't actually matter.
The CLR categorically refuses to consider two delegate types identical, even if their declaration is the same. It will not burn the extra CPU cycles to use reflection itself to check if they match, delegates are supposed to be fast and there's nothing cheap about checking compatibility. Type conversion is a compiler's job. So it will only accept an exact match, your reflection code needs to create a delegate of type ClassA.ErrorEventHandler. Of course you can't know the type, it is readily available however. It is EventInfo.EventHandlerType.
A second problem in your code is the delegate target, the method that runs when the event is raised. You now pass ClassA.Run(), that is not correct of course. You need to pass your own method, one that's compatible with the delegate. It could look like this:
private static void Callback(object sender, object data) {
// etc...
}
And modify the reflection code accordingly:
object obj = Activator.CreateInstance(type);
BindingFlags myBindingFlags = BindingFlags.Instance | BindingFlags.Public;
// Find the event and its type
EventInfo ei = obj.GetType().GetEvent("OnErrorHandler", myBindingFlags);
var delegateType = ei.EventHandlerType;
// Use our own event handler
var mycallback = typeof(Program).GetMethod("Callback", BindingFlags.Static | BindingFlags.NonPublic);
Delegate del = Delegate.CreateDelegate(delegateType, null, mycallback);
ei.AddEventHandler(obj, del);
// Call the Run method
MethodInfo methodInfo = obj.GetType().GetMethod("Run");
bool Result = (bool)methodInfo.Invoke(obj, null);
Note that the Callback event handler used object as the second argument type. Which is fine, it is compatible with the invisible ErrorEventArgs type. If you need to obtain the values of the passed object then you need to use Reflection in the callback as well.