将一个列表的内容复制到另一种不同类型的列表

Question

I am having trouble copying the contents of a List<TemplateSection> to List<Section> . These are defined as below:

List<TemplateSection> is :

public class TemplateSection
{
    public string SectionName { get; set; }
    public List<MyTemplateItem> MyTemplateItems { get; set; }
}

public class MyTemplateItem
{
        public string ItemName { get; set; }
        public string ItemText { get; set; }
}

List<Section> is:

public class Section
{
    public string SectionName { get; set; }
    public List<MyItem> MyItems { get; set; }
}
public class MyItem
{
    public string ItemName { get; set; }
    public string ItemText { get; set; }
    public string ItemValue { get; set; }
}

ItemValue does not need a value when it is copied or it could just be an empty string.

List<TemplateSection> is a list of sections and checkbox items in each section with a unique name for each checkbox. List<Section> is the values that are saved from the form when the user makes updates.

I have tried doing: List<Section> listSection = listTemplateSection.Cast<Section>().ToList(); but it fails to cast.

I don't know how else to describe this other than providing the definitions here. Please help!

Answer 1

The compiler can't guess how to convert from TemplateSection to Section . You must explicity do it yourself:

var ans = myTemplateSelections.Select(aTemplate => new Section {
        SectionName = aTemplate.SectionName,
        MyItems = aTemplate.MyTemplateItems.Select(ti => new MyItem {
            ItemName = ti.ItemName,
            ItemText = ti.ItemText //,
            // ItemValue = ???
        }).ToList();
    };

Per a couple of comments, you can use Cast if you are willing to write your own conversion operators.

Change your template classes to include the conversion operators:

public class TemplateSection {
    public string SectionName { get; set; }
    public List<MyTemplateItem> MyTemplateItems { get; set; }

    public static explicit operator Section(TemplateSection src) {
        return new Section {
            SectionName = src.SectionName,
            MyItems = new List<MyItem>(src.MyTemplateItems.Cast<MyItem>())
        };
    }
}

public class MyTemplateItem {
    public string ItemName { get; set; }
    public string ItemText { get; set; }

    public static explicit operator MyItem(MyTemplateItem src) {
        return new MyItem {
            ItemName = src.ItemName,
            ItemText = src.ItemText
        };
    }
}

Then you can use Cast :

var sections = new List<Section>(myTemplateSections.Cast<Section>());

Answer 2

C# does not provide duck typing , as you expect (it looks the same, so I should be able to cast it). Furthermore, C# allows covariance restrictions only on interfaces and delegates, which makes your use case complicated. And the List<T> is not covariant either ( IReadOnlyList would be), so more complexity added. With inheritance, covariance and an interface you could do this:

class Program
{

    static void Main(string[] args)
    {
        var list = new List<MySection>();

        list.Add(new MySection()
        {
            Items = new List<MyItem>()
            {
                new MyItem() { Name = "One", Text = "Two", Value = "Three" }
            }
        });

        // can access value here: list.First().Items.First().Value

        IEnumerable<ISection<TemplateItem>> genericList = list;

        foreach (ISection<TemplateItem> genericSection in genericList) 
        {
            // no value here
        }
    }

}

public interface ISection<out T> where T : TemplateItem
{

    string Name { get; }

    IEnumerable<T> Items { get; }

}

public class TemplateSection<T> : ISection<T> where T : TemplateItem
{

    public string Name { get; set; }

    public List<T> Items { get; set; }

    IEnumerable<T> ISection<T>.Items => Items;
}

public class TemplateItem
{
    public string Name { get; set; }
    public string Text { get; set; }
}

public class MySection : TemplateSection<MyItem>
{        

}

public class MyItem : TemplateItem
{
    public string Value { get; set; }
}

The covariant IEnumerable (defined as out T ) allows us to assign a MySection to a ISection<T> within the IEnumerable . I guess, there will be a more elegant way nevertheless.