I have different string distance metric implementations at hand (all of them are in C#) for example, Levensthein, NeedlemanWunsch, Jaccard, etc. The job of these are same basically; take two strings as input and return a similarity score in the range [0,1]. So, I planned to make these classes to implement the same basic interface, as in the following:
public interface IStringDistanceMetric
{
//Return a similarity between 0 and 1.
double CompareSimilarity(string strA, string strB);
}
Each of my metrics will implement this method. But there are some metrics which will directly operate on two strings, without any other input and there are some metrics which needs some extra parameters( like the penalty given for a gap in one of the input strings, etc.). In general, I can give these parameters either in the constructor stage or just before calculating the similarity score.
My question is, in general, what would be a good design practice in order to handle such differences between the concrete distance classes? I aim that the client code which wants to use any distance metric should be oblivious to any underlying implementation detail, after it has decided use a specific kind of metric. The most obvious way would be to implement something like:
IStringDistanceMetric metric;
if(metricType == Metric.NeedlemanWunsch)
{
metric = new NeedlemanWunsch(parametersNW);
}
else if(metricType == Metric.Levensthein)
{
metric = new Levensthein(parametersL);
}
.
.
.
But this doesn't look a good solution to me. I am kind of surprised to find myself stuck at such a basic looking design problem. Any help would be appreciated.
I guess this is highly dependant on how it is used; are the values of these parameters fixed or should they be provided when doing the comparison? If the number of possible values for these parameters is very low, the design used in .NET for StringComparers could be followed (courtesy of sourceof.net):
private static readonly StringComparer _invariantCulture = new CultureAwareComparer(CultureInfo.InvariantCulture, false);
private static readonly StringComparer _invariantCultureIgnoreCase = new CultureAwareComparer(CultureInfo.InvariantCulture, true);
private static readonly StringComparer _ordinal = new OrdinalComparer(false);
private static readonly StringComparer _ordinalIgnoreCase = new OrdinalComparer(true);
public static StringComparer InvariantCulture {
get {
return _invariantCulture;
}
}
If you are getting user input or configuration settings to specify your parameter values, and they vary each time you compare strings, a factory method would probably be an appropriate solution, the 'most obvious way' presented in your answer.
Collected from the Internet
Please contact [email protected] to delete if infringement.
Comments