CODEWITHSUNDEEP
c#
Nussbeisser
Nussbeisser

Reputation: 23

How to differentiate the same method invocations

I'll start with a code example. I have a following class

public class Foo
{
    public object DoSomething() {}
}

I also have some code that utilises method DoSomehting from class Foo.

public class Boo
{
    privite Foo foo;

    public void SomeMethod()
    {
        ...
        foo.DoSomething();
        ...
        foo.DoSomething();
    }
}

How could I distinguish those two calls foo.DoSomething() inside the Foo class?

What I came up with is to have an identification object passed in parameters for each call to DoSomething. Then in Foo class I would store the ids and compare them when new call is made.

public class Boo
{
    privite Foo foo;

    public void SomeMethod()
    {
        ...
        var idObjA = new IDObj(Guid.NewGuid());
        foo.DoSomething(idObjA);
        ...
        var idObjB = new IDObj(Guid.NewGuid());
        foo.DoSomething(idObjB);
    }
}

Maybe there is a better way to do it, or a pattern that I'm not aware of. I want the utilising code to be the least obscured so calls to the DoSomething method are as simple as possible.

To clarify my intentions. I'm implementing a message service with an ability for the user to check a checkbox on dialog box (e.g. Do not show again, or Apply to all). Code utilising the service can call the same method multiple times, to show an error message for example, but in different context. In other words, when user decided to not show that message again for particular action message box should not appear. Thus I need to know when method was called multiple times in the same context (action)

Upvotes: 1

Views: 96

Answers (3)

ADyson
ADyson

Reputation: 61859

Based on the extra info in your edit, it sounds like what you perhaps need to be doing is setting a separate property in your Foo class showing whether the "apply to all" or "do not show again" option has been checked for a particular context.

Then when you call DoSomething, it can check that property to know if it should show the dialog or not.

So in the simplest case you might do something like:

public class Foo
{
    public bool DoNotShow { get; set; };

    public void DoSomething() {
        if(this.DoNotShow == true) {
            // logic
        } else {
            // alternative logic
        }
    }
}

public class Boo
{
    privite Foo foo;

    public void SomeMethod()
    {
        ...
        foo.DoSomething();
        foo.DoNotShow = true;
        ...
        foo.DoSomething();
    }
}

The value could then be toggled on and off whenever you like.

N.B. You mentioned different "contexts" in which dialogs can be turned on and off.

For this, you could consider either giving this property the ability to store values for different contexts (e.g. in something like a Dictionary, perhaps) and then passing in the current context name to the DoSomething method when it's called. Or even pass in a totally separate "context" object to DoSomething each time, which contains the context name and the boolean indicating whether to show the dialog or not.

Or...using a different instance of Foo for each context might actually be more in line with object-oriented principles (in which case you could probably use the code exactly as per my example above). Again it depends exactly how the class the and the overall application works.

Upvotes: 0

skymon
skymon

Reputation: 870

If knowing the line number of the call helps, you could use one of the methods for getting the caller information described here. So for example:

public class Foo
{
    public object DoSomething() {
        StackFrame frame = new StackFrame(1, true);
        var method = frame.GetMethod();
        var lineNumber = frame.GetFileLineNumber();
    }
}

Upvotes: 0

div
div

Reputation: 925

Maybe you should expand a bit on what exactly you are trying to achieve. If you're using your instantiated class like described above and are just trying to differentiate between the first and second call, you can add a respective toggle field in your Foo class:

public class Foo
{
    private bool _firstCall = true;

    public object DoSomething() {
        if(_firstCall) {
            _firstCall = false;
            // first call logic
        } else {
            // second call logic
        }
    }
}

Upvotes: 1

Related Questions