C# .NET - Refactor a helper class to a design pattern

We have an ASP.NET application which has a reporting component. When the user runs the report, he selects various filters that we try to parse using the following example:

string lenderIds = string.Join(",", parameters["specificLenders"].AsDomainObject().Cast<Lender>().Select(l => l.Id).ToList());

You can imagine this gets tedious to code this millions of times for all the reports. So we created a helper class, ReportParameterCollectionValuesHelper (code below), to automatically handle retrieval of user input data for us. We simply call it using the following line of code:

ReportParameterCollectionValuesHelper helper = new ReportParameterCollectionValuesHelper(I1Parameters);

Now to access all the user input data, you just call it's properties, such as helper.LenderIds.

The problem is that this class is quickly growing out of control. To add a new type of filter parameter type, we need to modify a lot of code inside this helper class. So I was wondering if anyone could suggest an appropriate design pattern to refactor this class.

Would Abstract Factory be useful here, or Builder pattern perhaps?

public class ReportParameterCollectionValuesHelper
{
	#region Private Fields
	private const string BeginDateFilterName = "BeginDate";
	private const string EndDateFilterName = "EndDate";
	private const string TotalsOnlyFilterName = "Output";
	private const string SpecificAgentsFilterName = "specificAgents";
	private const string SpecificEntityFilterName = "specificEntity";
	private const string SpecificCarrierFilterName = "specificCarriers";
	private const string SpecificGeneralAgentFilterName = "specificGeneralAgents";
	private const string SpecificSalespersonFilterName = "specificSalesperson";
	private const string SpecificSubmittedByFilterName = "specificSubmittedBy";
	private const string SpecificQuotingForFilterName = "specificQuotingFor";
	private const string SpecificEntityUserFilterName = "specificEntityUser";
	private const string SpecificGoverningRegionFilterName = "specificGoverningRegion";
	private const string SpecificPortfolioRegionFilterName = "specificPortfolioRegion";
	private const string SpecificLenderFilterName = "specificLenders";
	private const string SpecificPayeeFilterName = "specificPayee";

	private readonly RDate _beginDate = RDate.Null;
	private readonly RDate _endDate = RDate.Null;
	private readonly Boolean _totalsOnly = false;
	private readonly string _specificAgentIds = string.Empty;
	private readonly string _specificEntityIds = string.Empty;
	private readonly string _specificCarrierIds = string.Empty;
	private readonly string _specificGeneralAgentsIds = string.Empty;
	private readonly string _specificSalespersonIds = string.Empty;
	private readonly string _specificSubmittedByIds = string.Empty;
	private readonly string _specificQuotingForIds = string.Empty;
	private readonly string _specificEntityUserIds = string.Empty;
	private readonly string _specificGoverningRegionIds = string.Empty;
	private readonly string _specificPortfolioRegionIds = string.Empty;
	private readonly string _specificLenderIds = string.Empty;
	private readonly string _specificPayeeIds = string.Empty;
	#endregion

	#region Properties
	public RDate BeginDate
	{
		get
		{
			return _beginDate;
		}
	}

	public RDate EndDate
	{
		get
		{
			return _endDate;
		}
	}

	public Boolean TotalsOnly
	{
		get
		{
			return _totalsOnly;
		}
	}

	public string SpecificAgentIds
	{
		get
		{
			return _specificAgentIds;
		}
	}

	public string SpecificEntityIds
	{
		get
		{
			return _specificEntityIds;
		}
	}

	public string SpecificCarrierIds
	{
		get
		{
			return _specificCarrierIds;
		}
	}

	public string SpecificGeneralAgentIds
	{
		get
		{
			return _specificGeneralAgentsIds;
		}
	}

	public string SpecificSalespersonIds
	{
		get
		{
			return _specificSalespersonIds;
		}
	}

	public string SpecificSubmittedByIds
	{
		get
		{
			return _specificSubmittedByIds;
		}
	}

	public string SpecificQuotingForIds
	{
		get
		{
			return _specificQuotingForIds;
		}
	}

	public string SpecificEntityUserIds
	{
		get
		{
			return _specificEntityUserIds;
		}
	}

	public string SpecificGoverningRegionIds
	{
		get
		{
			return _specificGoverningRegionIds;
		}
	}

	public string SpecificPortfolioRegionIds
	{
		get
		{
			return _specificPortfolioRegionIds;
		}
	}

	public string SpecificLenderIds
	{
		get
		{
			return _specificLenderIds;
		}
	}

	public string SpecificPayeeIds
	{
		get
		{
			return _specificPayeeIds;
		}
	}

	private string FilterValues { get; set; }

	private string OptionValues { get; set; }
	#endregion

	#region Ctor
	public ReportParameterCollectionValuesHelper(ReportParameterCollection parameters)
	{
		if (parameters == null) throw new ArgumentNullException();

		_beginDate = processDateParameter(parameters, BeginDateFilterName);
		_endDate = processDateParameter(parameters, EndDateFilterName);
		_totalsOnly = processBooleanParameter(parameters, TotalsOnlyFilterName);
		_specificAgentIds = processDomainTypeParameter(parameters, SpecificAgentsFilterName);
		_specificEntityIds = processDomainTypeParameter(parameters, SpecificEntityFilterName);
		_specificCarrierIds = processDomainTypeParameter(parameters, SpecificCarrierFilterName);
		_specificGeneralAgentsIds = processDomainTypeParameter(parameters, SpecificGeneralAgentFilterName);
		_specificSalespersonIds = processDomainTypeParameter(parameters, SpecificSalespersonFilterName);
		_specificSubmittedByIds = processDomainTypeParameter(parameters, SpecificSubmittedByFilterName);
		_specificEntityUserIds = processDomainTypeParameter(parameters, SpecificEntityUserFilterName);
		_specificQuotingForIds = processDomainTypeParameter(parameters, SpecificQuotingForFilterName);
		_specificGoverningRegionIds = processDomainTypeParameter(parameters, SpecificGoverningRegionFilterName);
		_specificGoverningRegionIds = processDomainTypeParameter(parameters, SpecificPortfolioRegionFilterName);
		_specificLenderIds = processDomainTypeParameter(parameters, SpecificLenderFilterName);
		_specificPayeeIds = processDomainTypeParameter(parameters, SpecificPayeeFilterName);
	}
	#endregion

	#region Methods
	private RDate processDateParameter(ReportParameterCollection parameters, string paramName)
	{
		RDate paramValue = RDate.Null;

		if (parameters[paramName] != null && parameters[paramName].AsDateTime().Count > 0)
		{
			paramValue = new RDate(parameters[paramName].AsDateTime()[0].Date);
		}

		return paramValue;
	}

	private Boolean processBooleanParameter(ReportParameterCollection parameters, string paramName)
	{
		Boolean paramValue = false;

		if (parameters[paramName] != null && parameters[paramName].AsBoolean() != null && !parameters[paramName].AsBoolean().IsNull && parameters[paramName].AsBoolean().Value == true)
		{
			paramValue = parameters[paramName].AsBoolean().Value;
			OptionValues += string.Format("{0}; ", parameters[paramName].DisplayName);
		}

		return paramValue;
	}
	/// <summary>
	/// 
	/// </summary>
	/// <param name="parameters"></param>
	/// <param name="paramName"></param>
	/// <returns></returns>
	public string processDomainTypeParameter(ReportParameterCollection parameters, string paramName)
	{
		string paramValue = string.Empty;

		if (parameters[paramName] != null)
		{
			switch (parameters[paramName].Type)
			{
				case ReportParameterType.DomainObject:

					if (parameters[paramName].AsDomainObject().Count > 0)
					{
						switch (parameters[paramName].DomainObjectType)
						{
							case DomainObjectParameterType.Agent:
							case DomainObjectParameterType.Entity:
							case DomainObjectParameterType.EntityAgentAndGeneralAgentOnly:
							case DomainObjectParameterType.CarrierAndGeneralAgentOnly:
							case DomainObjectParameterType.GeneralAgent:
							case DomainObjectParameterType.InsuranceCompany:
							case DomainObjectParameterType.Payees:
							case DomainObjectParameterType.Salesperson:

								paramValue = string.Join(",", parameters[paramName].AsDomainObject().Cast<Entity>().Select(x => x.Id).ToList());
								FilterValues += string.Format("{0}: {1}{2}",
									parameters[paramName].DisplayName,
									string.Join(", ", parameters[paramName].AsDomainObject().Cast<Entity>().Select(x => x.Code + " - " + x.Name1).ToList()),
									Environment.NewLine);

								break;

							case DomainObjectParameterType.CollectionAgency:

								paramValue = string.Join(",", parameters[paramName].AsDomainObject().Cast<CollectionAgency>().Select(agency => agency.Id).ToList());
								FilterValues += string.Format("{0}: {1}{2}",
									parameters[paramName].DisplayName,
									string.Join(", ", parameters[paramName].AsDomainObject().Cast<CollectionAgency>().Select(agency => agency.Code).ToList()),
									Environment.NewLine);

								break;

							case DomainObjectParameterType.PortfolioRegion:

								paramValue = string.Join(",", parameters[paramName].AsDomainObject().Cast<PortfolioRegion>().Select(r => r.Id).ToList());
								FilterValues += string.Format("{0}: {1}{2}",
									parameters[paramName].DisplayName,
									string.Join(", ", parameters[paramName].AsDomainObject().Cast<PortfolioRegion>().Select(r => r.Code + " - " + r.Name).ToList()),
									Environment.NewLine);

								break;

							case DomainObjectParameterType.Coverage:

								paramValue = string.Join(",", parameters[paramName].AsDomainObject().Cast<Coverage>().Select(cov => cov.Id).ToList());
								FilterValues += string.Format("{0}: {1}{2}",
									parameters[paramName].DisplayName,
									string.Join(", ", parameters[paramName].AsDomainObject().Cast<Coverage>().Select(cov => cov.Code + " - " + cov.Name).ToList()),
									Environment.NewLine);

								break;

							case DomainObjectParameterType.Lender:

								paramValue = string.Join(",", parameters[paramName].AsDomainObject().Cast<Lender>().Select(l => l.Id).ToList());
								FilterValues += string.Format("{0}: {1}{2}",
									parameters[paramName].DisplayName,
									string.Join(", ", parameters[paramName].AsDomainObject().Cast<Lender>().Select(l => l.Name).ToList()),
									Environment.NewLine);

								break;

							case DomainObjectParameterType.EntityUser:

								paramValue = string.Join(",", parameters[paramName].AsDomainObject().Cast<EntityUser>().Select(eu => eu.Id).ToList());
								FilterValues += string.Format("{0}: {1}{2}",
									parameters[paramName].DisplayName,
									string.Join(", ", parameters[paramName].AsDomainObject().Cast<EntityUser>().Select(eu => eu.FullName).ToList()),
									Environment.NewLine);

								break;
						}
					}

					break;

				case ReportParameterType.DomainEnum:

					if (parameters[paramName].AsDomainEnum().Count > 0)
					{
						paramValue = string.Join(",", parameters[paramName].AsDomainEnum().Cast<ReportParameterUserDefinedValue>().Select(x => x.Id).ToList());
						FilterValues += string.Format("{0}: {1}{2}",
								parameters[paramName].DisplayName,
								string.Join(", ", parameters[paramName].AsDomainEnum().Cast<ReportParameterUserDefinedValue>().Select(x => x.Name).ToList()),
								Environment.NewLine);
					}

					break;
			}
		}
		return paramValue;
	}

	public string GetFilterString()
	{
		string dateFilter = string.Empty;

		if (BeginDate != null && !BeginDate.IsNull && EndDate != null && !EndDate.IsNull)
		{
			dateFilter = string.Format("Date Range from {0} to {1}{2}", BeginDate.ToShortDateString(), EndDate.ToShortDateString(), Environment.NewLine);
		}

		return dateFilter + FilterValues;
	}

	public string GetOptionsString()
	{
		return OptionValues;
	}
	#endregion
}

Select allOpen in new window