C# - A Better Solution to a Generic Factory, or, is the callstack safe?

[Agrona]

I found this thread: http://www.thescripts.com/forum/thread233505.html only marginally helpful.

It seems that going through the callstack is the only way to determine which function may have called the function currently being executed. Is this thread-safe, or are there other alternatives (I'm pretty new to reflection; can it do that)?

Here's a bit of the design that leads me to ask this question. I'd be interested to know if there is a better way to accomplish this.

The idea behind what I'm doing is to build a factory class, which will produce the derived forms of a certain base class. It looks something like this:

    static public class MyFactory<MyClassT> where MyClassT : MyClass, new()      
    {
 
        static public MyClassT CreateMyClassT()
        {
            MyClassT retClass = new MyClassT();
            // ... details here
            return retClass;
        }
    }
 

Now, I would like the derived (and base) classes to have constructors that can only be called by the factory. I had accomplished this the following way (which looks like it works like C++ friend classes):

[assembly: InternalsVisibleTo("MyFactory.cs")]
 
    public class MyClass_Derived : MyClass
    {       
        internal MyClass_Derived()
            : base(MyClassEnum.DerivedType)
        {
        }
    }
}
 

This worked until I tried templatizing the Factory (which almost became a hideous switch statement before I got smart. Or, at least, before I thought I got smart.

That leaves me with the following:

• In order for the factory to create a new MyClassT, I need the : new() restriction.
• With the : new() restriction, the class must have a public constructor with no arguments.
• I wanted to get rid of the public argument-free constructor so that only the factory can construct these objects.

It appears that there is no way to have a generic Factory for a hierarchy of classes that doesn't have a public constructor. So, I thought, if I could check the class that called the constructor and throw an Exception if something other than the Factory tries to call it, I might approximate what I want.

Is there a better way to do this?

Thank you!

--

okay, so somehow I missed the .NET forum and ended up in C/C++. Sorry about that! (How do I move/delete this thread?)

[weaknessforcats]

Are you wanting a Parameterized Factory or an Abstract Factory??

Here is an example using a Parameterized Factory:

Factory.h:

class Base
{
 
};
class Factory
{
    public:
        enum ObjectType {DERIVED, DERIVED1};
        Base* BuildObject(enum ObjectType);
};
 

Factory.cpp:

class Derived : public Base
{
 
};
class Derived1 : public Base
{
 
};
Base* Factory::BuildObject(ObjectType arg)
{
    if (arg == Factory::DERIVED)
    {
        return new Derived;
    }
    //etc...
    return 0;  //didn't work
}
 

And finally the code used by main():

#include "Factory.h"
 
int main()
{
    Factory f;
    Base* obj = f.BuildObject(Factory::DERIVED);
}
 

The Factory.h does not include the class defintions for the derived classes. Since they are polymorphic, the base class public fuinctions consrtitute the interface so you don't need to know the derived class declarations.

There are other ways to do this using an Abstract Factory or by using a Singleton.\

In any case, do not use static classes or classes with static methods unless you have a gun to your head.

[JosAH]

@OP: I'll move your topic to the .NET forum.

kind regards,

Jos

[Agrona]

Are you wanting a Parameterized Factory or an Abstract Factory??
...

Base* Factory::BuildObject(ObjectType arg)
{
    if (arg == Factory::DERIVED)
    {
        return new Derived;
    }
    //etc...
    return 0;  //didn't work
}
 

Thanks for responding. I do want a Parameterized Factory. However, I already had the solution you presented and was trying to go for something much more maintainable. Instead of the giant switch statement that would become the inside of this factory (is this enum a, then make type a; is it enum b, then make type b, etc.), I was trying to use Generics (templates) to make it simpler.

In know exactly what I'd want in C++, which would be something like the following (consider this pseudocode, as I'm not sitting in front of a C++ compiler. My apologies if its broken somewhere):

<typename T>
class MyClassFactory<T>
{
 
  // insert singleton implementation here
 
  <typename T>
  T* MyClassFactory<T>::CreateMyClass()
  {
    return new T();
  }
}
 
 // The types I would create with the factory
 
class MyClassDerived public MyClass
{
  // Not sure on the syntax of friends and generic classes.
  friend class MyClassFactory<MyClassDerived>;
  private MyClassDerived() {} ;
 
  // more implementation
}
 

My post was that I seemed to be unable to produce something like this in C#.

Again, the ultimate goal here is to have a class that can only be produced by this factory. I have that at the moment, but only by using the less-than-desirable enum/switch solution. I want to move away from this, because the enums and derived classes are consistently being created and removed as the project grows and changes. Not having to cast the returned type to its derived class is also a pretty big bonus as far as ease of coding goes.

Thanks!

(Also, why the dislike of static?)

[Agrona]

@OP: I'll move your topic to the .NET forum.

kind regards,

Jos

Thanks for putting this in the right forum.

[Agrona]

OP Here.

I've been playing around, and this is exactly what I want. It's a shame that it's written in the wrong language. If anyone could help me convert this from C++ to C#, that would be awesome.

#include "GenericFactory.h"
#include "ClassDefinitions.h"
 
int main(int argc, char * argv[])
{
    MyClassDerivedA * derivedA;
    MyClassDerivedB * derivedB;
 
    derivedA = GenericFactory<MyClassDerivedA>::GetInstance()->CreateClass();
    derivedB = GenericFactory<MyClassDerivedB>::GetInstance()->CreateClass();
 
//    derivedA = (MyClassDerivedA *)EnumControlledFactory::GetInstance()->CreateClass(true);
//    derivedB = (MyClassDerivedB *)EnumControlledFactory::GetInstance()->CreateClass(false);
}
 

#ifndef GENERICFACTORY_H
#define GENERICFACTORY_H
 
template <typename T> class GenericFactory
{
public:
    static GenericFactory * GetInstance();
    T * CreateClass();
 
private:
    GenericFactory();
    static GenericFactory * p_self;
};
 
// implementation follows because C++ sucks with templates and includes.
 
template <typename T>
GenericFactory<T> * GenericFactory<T>::p_self = 0;
 
template <typename T>
GenericFactory<T>::GenericFactory() {};
 
template <typename T>
GenericFactory<T> * GenericFactory<T>::GetInstance()
{
    if ( p_self = 0)    { p_self = new GenericFactory<T>(); }
    return p_self;
}
 
template <typename T>
T * GenericFactory<T>::CreateClass()
{
    return new T();
}
 
#endif
 

#ifndef CLASS_DEFINITIONS_H
#define CLASS_DEFINITIONS_H
 
// In actuality, these definitions appear in a library somewhere.
class MyClass
{
protected:
    MyClass() {};
};
 
class MyClassDerivedA : MyClass
{
    friend class GenericFactory<MyClassDerivedA>;
private:
    MyClassDerivedA() {};
};
 
class MyClassDerivedB  : MyClass
{
    friend class GenericFactory<MyClassDerivedB>;
private:
    MyClassDerivedB() {};
};
 
#endif