// you don't have to put the arguments in a struct, but i recommend
// you do as it is more future proof - you can add more info to the
// struct without breaking user code that consumes it.
struct MyEventArguments {

}

// then you declare it just adding FlexibleDelegate!() around the
// plain delegate type you'd normally use
FlexibleDelegate!(void delegate(MyEventArguments args)) callback;

// until you set it, it will be null and thus be false in any boolean check
assert(!callback);

// can set it to the properly typed thing
callback = delegate(MyEventArguments args) {};

// and now it is no longer null
assert(callback);

// or if you don't care about the args, you can leave them off
callback = () {};

// and it works if the compiler types you as a function instead of delegate too
// (which happens automatically if you don't access any local state or if you
// explicitly define it as a function)

callback = function(MyEventArguments args) { };

// can set it back to null explicitly if you ever wanted
callback = null;

// the reflection info used internally also happens to be exposed publicly
// which can actually sometimes be nice so if the language changes, i'll change
// the code to keep this working.
static assert(is(callback.ReturnType == void));

// which can be convenient if the params is an annoying type since you can
// consistently use something like this too
callback = (callback.Parameters params) {};

// check for null and call it pretty normally
if(callback)
	callback(MyEventArguments());