如何使用C＃泛型将类的对象转换为T类型的对象？

Question

I have some classes that are supposed to generate charts. I have three classes that use different type of data for the charts' series. I will provide just the properties of these classes, to avoid confusion :)

public class PointBase
{
    public decimal X { get; set; }
}

public class Point : PointBase
{
    public decimal Y { get; set; }
}

public class Bubble : Point
{
    public decimal Size { get; set; }
}

These three classes are used as the basic piece of data in the series of the charts. The series of the charts are represented as Dictionary objects in other three classes (the chart ones). I won't provide code of the chart classes in order to focus on the specific problem. I will just provide the names of the classes:

1. CoordinateChart (using PointBase as a basic piece of data).
2. ScatterChart (using Point).
3. BubbleChart (using Bubble).

I have the following method that does exactly the same algorithm for all my chart classes. That's why I decided to make the method using generics.

    public Dictionary<string, T[]> GenerateSeriesDataDictionary<T>(string[] series, string[] categories) where T : PointBase, new()
    {
        // Create a new Dictionary.
        Dictionary<string, T[]> seriesData = new Dictionary<string, T[]>();

        // Gets the number of categories and assigns the categoriesNumber variable with the returned value.
        int categoriesNumber = categories.Length;

        foreach (string serie in series)
        {
            Dictionary<string, T> categoriesData = (Dictionary<string, T>)GetCategoriesData(serie);

            // Create a new array of Ts that will store the data for the current serie.
            T[] dataArray = new T[categories.Length];

            for (int i = 0; i < categoriesNumber; i++)
            {
                // If the serie contains a value for the current category, store it in the array.
                // Otherwise, set the value of the current element of the array to the default one.
                dataArray[i] = categoriesData.ContainsKey(categories[i]) ? categoriesData[categories[i]] : new T();
            }

            // Add the dataArray to the seriesData Dictionary.
            seriesData.Add(serie, dataArray);
        }

        return seriesData;
    }

So, the above method recieves two arrays of strings. The first one represents the names of the series, for example "Tokyo" and "London". The second one represents the names of the categories for the chart - for example, the names of the months - "January", "February", etc.

This method is supposed to create a Dictionary object, that uses the name of a serie as a key and a corresponding array of objects, representing the data for each category (in my case - each month). For example, a single key-value pair in the Dictionary should look something like this: Key: "London"; Value: 17, 16, 20, 25 (let's say the data represents maximum temperature for each month).

I'm basically executing the same algorithm, whenever I'm creating a line, a scatter or a bubble chart (represented by the CoordinateChart, ScatterChart and BubbleChart classes). The only thing that is different is the type of the dictionary I'm generating.

1. CoordinateChart uses Dictionary(string, PointBase[])
2. ScatterChart uses Dicitonary(string, Point[])
3. BubbleChart uses Dictionary(string, Bubble[])

I replaced the '<' and '>' characters with '(' and ')', because they seem to disappear :)

That's why I decided to put the logic that is supposed to generate the Dictionary object in a separate method and then override this method in each of these classes.

My method looks like this:

    public virtual Dictionary<string, PointBase> GetCategoriesData(string serie) 
    {
        Dictionary<string, PointBase> categoriesData = sqlResultDataTable.AsEnumerable()
            .Where(row => row["City"].ToString() == serie)
            .Select(row => new KeyValuePair<string, PointBase>(row["Month"].ToString(), new PointBase(decimal.Parse(row["Temperature"].ToString()))))
            .ToDictionary(item => item.Key, item => item.Value);

        return categoriesData;
    }

This method basically gets all the key-value pairs representing a "Month" and a "Temperature" value for a serie (for instance, "London").

So, I'm doing all this in order to have code reusability. Otherwise, I could do the same thing in all of my three classes and I could provide an individual implementation of the GenerateSeriesDataDictionary method in each one, but I don't think this is a good approach.

Everything is okay, but I get an Error on this line:

Dictionary<string, T> categoriesData = (Dictionary<string, T>)GetCategoriesData(serie);

The message of the error states: 'Cannot convert type Dictionary(string, PointBase) to Dictionary(string, T)'.

I replaced the '<' and '>' characters with '(' and ')', because they seem to disappear :)

What can I do?

Answer 1

Create a base class/interface with a generic type parameter.

public abstract class Chart<T> where T : PointBase, new()
{
    public abstract IDictionary<string, T> GetCategoriesData(string serie);

    public IDictionary<string, T[]> GenerateSeriesDataDictionary<T>(string[] series, string[] categories)
    {
        // Call GetCategoriesData, etc.
    }
}

Then create derived classes with specific point types:

public class ScatterChart : Chart<Point>
{
    public override IDictionary<string, Point> GetCategoriesData(string serie)
    {
        // Create new Point and set its properties.
        // We know it is a Point because we specified it in the class generic type.
    }

    // ...
}

public class BubbleChart : Chart<Point>
{
    public override IDictionary<string, Bubble> GetCategoriesData(string serie)
    {
        // Create new Bubble and set its properties.
        // We know it is a Bubble because we specified it in the class generic type.
    }

    // ...
}

Answer 2

You cannot cast Dictionary<string, PointBase> to eg Dictionary<string, Bubble> , so that's why your code won't compile. They are not the same thing.

You either need to declare categoriesData as a Dictionary<string, PointBase> , or make the GetCategoriesData() method generic.

Answer 3

This is a problem of type variance , covariance to be more specific.

.Net let's you do a safe covariance only, otherwise it would mean

Dictionary<string, Bubble> bubbles = GetBubbles();
Dictionary<string, PointBase> points = bubbles;

points["London"] = new Point(); //crash, not a Bubble

Consider using IEnumerable that is a readonly interface with covariant generic type.