Regardless of whether or not this is a good idea, is it possible to implement an interface where the executing function is aware of the calling object's type?
class A
{
private C;
public int doC(int input)
{
return C.DoSomething(input);
}
}
class B
{
private C;
public int doC(int input)
{
return C.DoSomething(input);
}
}
class C
{
public int DoSomething(int input)
{
if(GetType(CallingObject) == A)
{
return input + 1;
}
else if(GetType(CallingObject) == B)
{
return input + 2;
}
else
{
return input + 3;
}
}
}
It seems to me like this is a bad coding practice (because the parameters don't change, but the output would) but aside from that is it possible?
I'm in a situation were I want a few specific types to be able to call a certain function, but I can't exclude access to the function. I thought about having a "type" parameter
DoSomething(int input, Type callingobject)
But there's no guarantee that the calling object would use GetType(this), as opposed to GetType(B) to spoof a B regardless of their own type.
Would this be as simple (relatively simple) as examining the callstack?
EDIT
Please vote up JaredPar's answer (if you want) as well as John Feminella's. I could not mark both answers as accepted, and I accepted John Feminella's answer because it is specifically what I asked for, as opposed to Jared's answer which brought up a solution which I had not previously considered.