抽象工厂实现错误

Question

I want to implement Abstract Factory pattern to maximize code efficiency to read my coımmon reference types. To achieve this I have the following implementations

and to implement the pattern I have implemented the following:

My code for the RefEntityFactor class is :

public class RefEntityFactory<T> : IRefEntityFactory<T> where T : IRefEntity
{
    public List<T> Search(string sp_name, int? id, string code, int? statusid)
    {
        List<T> irefs = new List<T>();
        string procName = sp_name;
        SqlConnection conn = null;

        using (conn = GetConnection())
        {
            SqlCommand cmd = new SqlCommand(procName, conn);
            cmd.CommandType = CommandType.StoredProcedure;

            if (id.HasValue)
                cmd.Parameters.AddWithValue("@ID", id.Value);
            if (!string.IsNullOrEmpty(code) && !string.IsNullOrWhiteSpace(code))
                cmd.Parameters.AddWithValue("@CODE", code.Trim());
            if (statusid.HasValue)
                cmd.Parameters.AddWithValue("@STATUS", statusid.Value);

            SqlDataReader rd = cmd.ExecuteReader();
            while (rd.Read())
            {
                RefEntity refe = new RefEntity();
                refe.Id = int.Parse(rd["ID"].ToString());
                refe.Code = rd["CODE"].ToString();
                refe.Status = short.Parse(rd["STATUS"].ToString());
                IRefEntity iref = (IRefEntity)refe;

                irefs.Add((T)iref);    // Exception will be THROWN HERE!!!!
            }
            rd.Close();
        }
        return irefs;
    }
}

Then I implement a class for spesific type:

as

public static List<IPaymentType> SearchPaymentTypes(int? id, string code, int? statusid)
    {
        RefEntityFactory<IPaymentType> fact = new RefEntityFactory<IPaymentType>();

        return fact.Search(@"[dbo].[SEARCH_PAYMENTTYPES]", id, code, statusid);
    }

But obviously when I run the code it throws an exception at the line where I mark as comment.

How can I correct my implementation?

Regards.

Answer 1

Ultimately, this will be because RefEntity isn't of type T , have you tried taking the approach by constructing the new T , so something like this in your while loop:

T refe = new T();
refe.Id = int.Parse(rd["ID"].ToString());
refe.Code = rd["CODE"].ToString();
refe.Status = short.Parse(rd["STATUS"].ToString());

irefs.Add(ref);

You'll also need to extend your generic constraint to limit your T to require a parameterless constructor as well, so something like:

public class RefEntityFactory<T> : IRefEntityFactory<T> where T : IRefEntity, new()

also you should change the SearchPaymentTypes as follows to make it work:

public static List<IPaymentType> SearchPaymentTypes(int? id, string code, int? statusid)
    {
        RefEntityFactory<PaymentType> fact = new RefEntityFactory<PaymentType>();
        List<PaymentType> list = fact.Search(@"[dbo].[SEARCH_PAYMENTTYPES]", id, code, description, statusid);

        return list.Select(x => (IPaymentType)x).ToList();
    }

Answer 2

The problem is the RefEntityFactory creates RefEntity objects. RefEntitys cannot be cast to IPaymentType because they don't implement IPaymentType.

You don't need to use generic parameters to implement the abstract factory pattern. The abstract factory's method can return IRefEntity:

interface IRefEntityFactory
{
    List<IRefEntity> Search(string sp_name, int? id, string code, int? statusid);
}

and concrete factories would return the various concrete entity types that implement IRefEntity:

class PayrollEntityFactory : IRefEntityFactory
{
    public List<IRefEntity> Search(string sp_name, int? id, string code, int? statusid)
    {
        List<IRefEntity> ret = new List<IRefEntity>();
        ret.Add(new PaymentType());
        return ret;
    }
}

or

class NnnnEntityFactory : IRefEntityFactory
{
    public List<IRefEntity> Search(string sp_name, int? id, string code, int? statusid)
    {
        List<IRefEntity> ret = new List<IRefEntity>();
        ret.Add(new NnnnType());
        return ret;
    }
}

Or the abstract factory could be an abstract class instead of an interface. That would allow common code to be shared by all implementations and avoid duplication of much of eg the SQL queries. But the actual concrete object (eg payroll) creation cannot be shared, each object's construction will need to be unique.