How to abstract operation from unrelated types?

Question

REMARK after rethinking my issue. Though the best solution for my exact example with WriteData method was proposed by @Dogu Arslan, the issue in question's title was actually solved by @InBetween and @Fabio. I. e. for my exact example with WriteData method it is better to move the conversion logic out of WriteData method, but to abstract the logic from unrelated types it is better to use proposed overloading. So all the three answers are helpful for me.

I already have read the following similar questions - 1, 2, and others - but not have come with something suitable solution in my case.

My case is: I have the following simple method. The important part is the line with commentary and the "source" parameter. The rest part is not so important and serves only to show that there is an "operation" from the question's title.

void WriteData(
    int count, 
    int currentIndex, 
    List<byte> source, 
    StreamWriter sw, 
    string fileName)
{
    var countToWrite = count - currentIndex;

    if (countToWrite == 0)
        return;

    if (sw == null)
        sw = new StreamWriter(GetFullPath(fileName));

    //---------- Source's elements must be converted to string.
    var dataToWrite =
        source.GetRange(currentIndex, countToWrite)
        .Select(x => Convert.ToString(x));

    StringBuilder sb = new StringBuilder();

    foreach (var item in dataToWrite)
        sb.AppendLine(item);

    sw.Write(sb.ToString());
}

For now I want the "source" parameter to be list with bytes, or doubles, or strings. Have I write three copies of WriteData method with only single change - the type of list in "source"? Or there is a better approach?

I tried type constraint, but to what type to constrain?

I tried to check the type and to throw exceptions if it is not in my type list (byte, double, string). But exceptions work only at run-time, and I want it to work in compile-time.

For now I have to restrict myself with run-time type checking as temporary solution, but, as I mentioned before, it is not suitable in perspective.

Answer 1

Why not using overload methods with one "hided" actual solution

public void WriteData(List<byte> source) { WriteData<byte>(source); }
public void WriteData(List<double> source) { WriteData<double>(source); }
public void WriteData(List<string> source) { WriteData<string>(source); }

private void WriteData<T>(List<T> source)
{
     // Your actual implementation
}

In private method you can check types and throw exception when wrong type is given, in case you want "protect" from making private method public by "mistake".

Answer 2

The best solution is to publicly expose the needed overloads and then delegate implementation to a private generic method:

public void WriteData( , , List<string> source, , ) { WriteData<string>(...); }
public void WriteData( , , List<byte> source, , ) { WriteData<byte>(...); }
public void WriteData( , , List<double> source, , ) { WriteData<double>(...); }

private void WriteData<T>( , , List<T> source, , ) 
{ 
    Debug.Assert(typeof(T).Equals(typeof(string)) ||
                 typeof(T).Equals(typeof(byte)) ||
                 typeof(T).Equals(typeof(double)));
    ...
}

Answer 3

One thing you could do is to remove the string conversion responsibility to another class altogether.ie. StringConverter class which would have overloaded constructors that would take these different input types to convert them to string and provide a method that returns a string. That way even if you extend in future the types you support you would not need to change this method here in your example, all of that would be transparent behind you string converter class. The checks will also be compile time because string converter class would take the input through its constructor. Yes this would mean everytime you want to call WriteData method you would need to instantiate a new StringConverter object but C# does not provide type constraints on the level you ask out of the shelf.