Refactor static methods for loose coupling.

Praveen Raghuvanshi

Hi, I have been trying to refactor the legacy code and make it loosly coupled. I came across a class which resembles as shown below.

public Class MyClass
{
private int _a;
private ushort _b;
private int _c;

public MyClass(int a, ushort b, int c)
{
	\_a = a;
	\_b = b;
	\_c = c;
}

public static MyClass FromBytes(byte\[\] params)
{
	int a = BitConverter.ToInt32(params, 0);
	ushort b = BitConverter.ToUInt16(params, 1);
	int c = BitConverter.ToInt32(params, 2);

	return new MyClass(a, b, c);
}

public int A
{
	get
	{
		return \_a;
	}
	set
	{	
		\_a = value;
	}
}

}

public Class MyConsumer
{
public void MyMethod()
{
// 1st way to create an instance
MyClass myClass1 = new MyClass(2, 3, 4);
int a = myClass1.A;

	// 2nd way of creating an instance 
	byte\[\] bytes = {8, 7, 6};
	MyClass myClass2 = MyClass.FromBytes(bytes);
	int a1 = myClass2.A;
}

}

'MyClass' has been created in two ways. - creating an instance using a 'new' operator. - Through a static method 'FromBytes'. As seen above MyClass is tightly coupled to MyConsumer class. I need to provide an abstraction for MyClass. I thought of creating an Inteface 'IMyClass' which has a property 'A'.

interface IMyClass
{
int A { get; set;}
}

MyClass shall have 2 overloaded constructor as shown below.

public Class MyClass : IMyClass
{
private int _a;
private ushort _b;
private int _c;

public MyClass(int a, ushort b, int c)
{
	\_a = a;
	\_b = b;
	\_c = c;
}

public MyClass(byte\[\] params)
{
	\_a = BitConverter.ToInt32(params, 0);
	\_b = BitConverter.ToUInt16(params, 1);
	\_c = BitConverter.ToInt32(params, 2);
}

public int A
{
	get
	{
		return \_a;
	}
	set
	{	
		\_a = value;
	}
}

}

I wanted to create an instance of MyClass in MyConsumer class through some creational pattern such as Factory. I don't know how to create an instance of a class which has its constructor overloaded. Questions: - How to provide abstraction to static methods? - How to create an instance of a class which has its constructor overloaded? I found this link useful, however it does not server my purpose of creating an object through a factory. Kindly share your view on this and let me know if you need more information. Thanks in advance!

Bernhard Hiller

Constructors are a specialised kind of static methods. I often prefer a "normal" static method over a constructor when it has a specialised purpose, e.g. public static MyClass FromFile(string filename). When it comes to the factory method with overloaded constructors of the classes, there are some possibilities: - use an overloaded factory method, corresponding to the overloads of the constructors - use an empty constructor and then set the properties - create an extra constructor accepting an object[] args parameter Personally I do not like any of those options, I doubt that the factory method is a good option in such a case.

jschell

Use a factory. The factory is derived from an interface. The real factory uses the methods on the class that already exists. The consumer object uses the real factory unless a static method (on option) is called to set a different factory.

Praveen Raghuvanshi

Thanks Bernhard for the your time. If we go with the static methods, I believe it would be tightly coupled and factory seems reasonable to me...

Praveen Raghuvanshi

Thanks jschell for your time. As per my understanding based on your inputs, we need to create a factory. So, in the sample code, it would be something like this. interface IMyClassFactory { IMyClass Create(int a, ushort b, int c); IMyClass Create(byte[] bytes); } and its implementation would be something like this. public class MyClassFactory : IMyClassFactory { public IMyClass Create(int a, ushort b, int c) { return new MyClass(a, b, c); } public IMyClass Create(byte[] bytes) { int a = BitConverter.ToInt32(params, 0); ushort b = BitConverter.ToUInt16(params, 1); int c = BitConverter.ToInt32(params, 2); return new MyClass(a, b, c); } } Consumer: public Class MyConsumer { public void MyMethod() { IMyClassFactory myClassFactory = new MyClassFactory(); // we can inject this // 1st way to create an instance IMyClass myClass1 = myClassFactory.Create(2, 3, 4); int a = myClass1.A; // 2nd way of creating an instance byte[] bytes = {8, 7, 6}; MyClass myClass2 = myClassFactory.Create(bytes); int a1 = myClass2.A; } } Please correct me if I have misunderstood something here. Appreciate, if you can explain with a small example. Is it acceptable to create an overloaded method in a factory as factory takes and parameter which defines the type of object required?

jschell

public static class FactorySource
{
// There are all sorts of ways to implement this class

 public static IMyClassFactory Factory { get; set; }

 static FactorySource()
 {
     Factory = new MyClassFactory();
 }

}

...
public void MyMethod()
{
IMyClassFactory myClassFactory = FactorySource.Factory;
...