Cross-Class calling without passing references: How can do?

louarnold

I'm working with VC 2010 Express with dotNet V4 under Windows XP. I have a small Windows Forms application with a main form and a subform. I have also constructed a utility class of useful functions. There will only ever be one instance of it, and I cannot make it a static class. How do I code a call from the subform to a public method of the utility class without passing a reference of the utility class to the subform?

Is there away to remove the utility class from the main project so as to allow any other classes to call the public methods directly (ie without passing around references)?

Just a note: Singletons and DLLs don't solve the problem of having to pass references. So forget those answers.

8 Replies

Know the answer? Post it — somebody with the same question will find it here.

louarnold15y ago
To make further comments clear: I have finaly understood that what I wanted would not change the coupling (how many cross-calls) between components although it would increase the coheasion (how how much the components must know about each other). The goal was re-usable code that requires no cohesion, and as little coupling as possible.
The static proxy that you mentioned are somewhat similar to the Singleton pattern. I did some tests and found out that the singleton code really does allow access to anything from anything. The code:
SingletonClass.Instance.DoSomething();
really can call Do Something from anywhere.
But this comes with a price: the hard-coded name 'SingletonClass" means that the caller knows about the callee, and that's not good for a re-usable component.
The better solution is in fact the C# Interface. I had abandoned it, but now I see that they eliminate the cohesion, at the expense of more complicate coupling - if not more of it.
Sam Hobbs15y ago
I have also used older technology. When I did a bit of programming for Bank of America I used punched cards. In our day, we had to do static links. That was not too bad but it is extra work. I used IBM COBOL in the 1980's with dynamic linking. It was a feature of the compiler. Windows supports dynamic linking as part of the operating system. Dynamic linking was a good thing before Windows and it is a good thing now.

Note that you are still explaining what you want in terms of what you don't want.

Please don't ignore what I said about a static item for an instance of the class. The class does not need to be static nor anything in the class.
louarnold15y ago
To Volpes:

I understand now, and yes, it does seem more complex than it needs to be. But thanks for trying.
louarnold15y ago
To Sam Hobbs:

Static classes cannot inherit, and in some classes I have to inherit C# interfaces. Static classes also can't have a "state" because they may be called from different threads. But they also cannot have instance variable because they are static.

I'm an programmer from the days when classes didn't exist. (and that wasn't THAT long ago.) At that time you could write utility code, compile it with test code and test it, and then compile it with one or more other applications. With OO techniques, however, one seems to need much greater coupling. I ask for an OO technque that gives me what I had without OO, beacuse I don't have enough experience to know if such an architecture exists in OO.

(Sorry. I'm new to this forum and I don't know how to get a quote in a reply.)
Vulpes15y ago
Suppose at the moment your class is defined something like this:

public class MyClass
{
public MyClass()
{
// do any initialization in here
}

public void MyMethod()
{
// code
}

public void MyMethod2(int i)
{
// code
}
}

To prevent any other class from obtaining a reference to this class, you could introduce a static proxy method in the following fashion:

public class MyClass
{
private static MyClass mc;

static MyClass()
{
mc = new MyClass();
}

// make instance constructor and methods private

private MyClass()
{
// do any initialization in here
}

private void MyMethod()
{
// code
}

private void MyMethod2(int i, string s)
{
// code
}

// introduce static method as a proxy for calling instance methods:

public static void MyStaticMethod(string methodName, object[] args)
{
switch (methodName)
{
case "MyMethod" :

mc.MyMethod();
break;

case "MyMethod2" :

mc.MyMethod2((int)args[0], (string)args[1]);
break;

default :

throw new ArgumentException ("Method doesn't exist");
}
}

You could then indirectly call MyMethod2 like this:

MyClass.MyStaticMethod("MyMethod2", new object[]{1, "Hello"});
louarnold15y ago
I don't understand what you mean by a "static proxy method". I know what a proxy is in general, but not in a technical sense.
Sam Hobbs15y ago
Perhaps if you explained why you did not want to use a static item then someone could suggest a solution. Note that as it is your request just says what you don't want to do but there really is not much describing what you do need to do. Read your question; what part of it says what you do want to do instead of saying what you don't want to do?

You don't have to make all your methods or the class static or anything such as that; you can have a single static instance of an object of the class.

Just a note: dwelling on the negative is likely to cause all answers to be forgotten.
Vulpes15y ago
If you don't want your subform (or other classes) to have a reference to the only instance of your utility class, then all you can do is to have static proxy methods for each instance method and call those instead. If the instance methods would never be called directly, then there would be no point in making them public but the static proxy methods would, of course, need to be public (or internal).

You could reduce the number of static proxy methods by passing the name of the instance method as one of its parameters but, unless you were happy to pass the other arguments as an object array, then you could only use the same proxy method for instance methods with the same signature.

The single instance could be created in a static constructor of the utility class by calling a private instance constructor and the reference could then be stored in a private static field.

However, I can't really see what advantage this rigmarole would give you compared to a 'normal' static class.