Easy creation of a wrapper class that implements an interface

[michaelcheers]

Example:

var list = new SuperList(new());
list.Add("Hello");
list.Add("Hello World"); // Cannot add "Hello World"

public class AlphabeticList : IList<string>
{
    public List<string> _innerList;
    public IList<string> => _innerList;

    public AlphabeticList (List<string> innerList) => _innerList = innerList;

    public new void Add (string value)
    {
        if (value.Any(c => !char.IsLetter(c))) throw new ArgumentException($"Cannot add {value}.");
        base.Add(value);
    }
}

Right now, the lightbulb will recommend "Implement ... through ...".

I propose we make this a language feature.

[ZacharyPatten]

Why would you not just inherit List<string> instead of IList<string> in the example you provided?

public class AlphabeticList : List<string>
{
    public AlphabeticList(IEnumerable<string> strings) => AddRange(strings);

    public new void Add(string value)
    {
        if (value.Any(c => !char.IsLetter(c))) throw new ArgumentException($"Cannot add {value}.");
        base.Add(value);
    }
}

[michaelcheers]

This requires making a new list which greatly impacts performance.

[michaelcheers]

Maybe the constructor could be amended to check the existing list though.

[ZacharyPatten]

Can you provide an example? There is certainly a way around re-allocation if you add the right overloads.

Also, this topic could also be handled with an extension method rather than a custom type:

public static class Extension
{
    public static void AddAlphabetic(this List<string> list, string value)
    {
        if (value.Any(c => !char.IsLetter(c))) throw new ArgumentException($"Cannot add {value}.");
        list.Add(value);
    }
}

Just because you have new before the method doesn't mean the base version can't be called. So you don't actually have any protection that the list only contains alphabetical strings:

using System;
using System.Collections.Generic;
using System.Linq;

IList<string> list = new AlphabeticList();
list.Add("Hello");
list.Add("Hello World"); // CAN ADD "Hello World" (no exception)
Console.WriteLine(string.Join(Environment.NewLine, list));

public class AlphabeticList : List<string>
{
    public AlphabeticList() : base() { }

    public AlphabeticList(IEnumerable<string> strings) => AddRange(strings);

    public new void Add(string value)
    {
        if (value.Any(c => !char.IsLetter(c))) throw new ArgumentException($"Cannot add {value}.");
        base.Add(value);
    }
}

the above program doesn't throw.

[Joe4evr]

By the way, this falls out of the fact that you shouldn't inherit from List<T> to begin with. If you follow the recommendation and inherit from Collection<T>, then the above problem goes away because override ensures your custom logic is always called regardless of the variables static type.

[333fred]

Duplicate of #234.