[RESOLVED] Mapping non-generic interfaces to generic collections

[wolf99]

In this SO question, https://stackoverflow.com/a/46363899/1292918, Hans Passant mentions:

"Mapping your own non-generic interface to a generic collection type"

What is meant by this exactly? How does one go about it?

My initial though was that it meant replacing generic interface usage with non-generic ones, eg, replacing IList<T> usage with IEnumerable or ArrayList usage.

But then I thought maybe it means creating my own IStringList type to replace IList<T> with instead of either of the aforementioned types... that would mean the following, right?

public interface IStringList : IList<string> { /* empty */ }

Update:Asked Hans about this latter code in a comment, he said "No, encapsulation is the appropriate choice". Unsure what is meant by this but SO is not the format to dig into details really

[techgnome]

Not sure... the way I interpreted the title is you create your own type on the surface, using generics under the covers. For instance, you can't expose a List<Integer> to COM ... so you create a new class structure that has all the features of a List<T> but is type specific externally, even though it is using generics under the cover. Then COM interacts directly with the non-generic class. That's what's meant by the comment "encapsulation is the appropriate choice." ... you encapsulate the functionality of the generic into something that isn't generic.

-tg

[wolf99]

Thanks TechGnome!

My understanding of what is actually the best way to do this is... patchy (Friday brain). Something like the following should cover it?

public class StringList : IList<string>
{
    private List<string> items;
 
    public StringList() { items = new List<string>(); }
    public StringList(System.Collections.IEnumerable collection) { items = new List<string>(collection as IEnumerable<string>); }
    public StringList(int capacity) { items = new List<string>(capacity); }
    public int Capacity { get=> items.Capacity; set => items.Capacity = value; }
    public int Count { get => items.Count; }
    public string this[int index] { get => items[index]; set => items[index] = value; }
 
    //etc
}

[techgnome]

Yes... except that second constructor isn't necessary... you're not doing anything with the collection passed in, and I don't know if IEnumerable is exposed to COM, so I don't even know if COM could call that particular signature.

Also, I'm assuming that the //etc includes all your .Add methods, .Remove, .RemoveAt, and so on...

-tg

[Sitten Spynne]

I seem to always regret trying to help you.

What an *******. I wouldn't bother asking him any further questions, he doesn't know anything worth knowing. It's a good thing he's deleted his answer, but I've flagged it anyway.

What he meant before revealing himself as a jerk:

Generic types cannot be exposed to COM. At all. There are no tricks to make it work. You can't move it to a property to make it work, because it's still a generic type.

But you CAN write a type that contains the generic type and delegates work to the generic type. Non-generic types can be exposed. IEnumerable, in particular, is visible to COM, as is IList.

So here's what I think he meant by "encapsulation is the way", he was probably in a hurry to play with the broomstick in his anus and didn't have time to type it out. It'd be nice if he'd actually answered your question. I'm no COM expert but I think I see the shape of this problem:

Say you have an IList<string> you want to expose to COM. You can't. The end. But IList is COM-visible. It's not enough to just cast your object to an IList, though. It's still an IList<string> and is still going to cause problems. So you need to make something that HAS AN IList<string>, not something that IS AN IList<string>:

[ComVisible(true)]
public class StringListWrapper : IList {

    private IList _internalList;

    public StringListWrapper(IList genericList) {
        if (!(genericList is IList<string>)) {
            throw new ArgumentException("Sorry, Charlie.", "genericList");
        }

        _internalList = genericList;
    }

    public int Add(object value) {
        return _internalList.Add(value);
    }

    public void Clear() {
        _internalList.Clear();
    }

    // ... dozens of other methods

I'm almost positive if you follow that pattern it will work, or it's at least close to what Hans was getting at before nature called. The important part about writing these wrappers is if you expose a generic type AT ALL, even if you hide it behind a cast to a less-specific interface, that's not going to work in COM. But my guess is if you make a type like this that keeps all the generic code on the ".NET side", it will work.

But it's probably just easier to use ArrayList and have some type discipline.

*edit* Oh, I see you sort of stumbled on that already. Whoops. I saw the SO post and got so mad I had to type a reply and didn't read the rest.

[wolf99]

Thanks for the added clarity Sitten. I don't have enough rep to see deleted answers on SO, so I had no idea why he'd deleted it... I opened the question here in addition to the SO one because I didn't want to be a help vampire in SO's Q&A format (or at all!) but the line is much tighter there). I thought my single line comments wouldn't be anywhere near that line even so. Funny thing is I rarely get answers from Hans (since ever) so I'm not sure what his "always" refers to... never mind

I had begun by considering ArrayList but it seemed to be kind of a code smell to cripple the types used in the interface so much for .Net clients just to try to serve COM clients (equal probability of both but there is no data on that yet). Chances are I'd end up constructing the collection initially as a tightly-typed List<> anyway before passing it out to the client as an ArrayList who, if a .Net client, would then likely want to convert it back again - code smell.

Below is what I've got now. Hopefully it is generic enough and tidy enough to be useful to others also, at least saving them some typing. I may add this to the code vault if you folks think it would be useful in that regard?

FYI, if either of you are on SO, and would like to copy-pasta your answers over to there, they are both good enough to answer the question as it and they stand so I'll accept there too :-)

Usage:

IStringList Foo1 = new StringList();
    IList Foo2 = new StringList();
    // or either of
    IList<string> Foo3 = new StringList();
    StringList Foo4 = new StringList();
    // though sadly it doesn't work the other way
    IStringList Foo5 = new List<string>(); // doesn't work

public interface IStringList : IList<string>, IList 
    { 
        new int Count { get; }
        new string this[int index] { get; set; }
    }
 
    public class StringList : IStringList
    {
        private const string ConversionErrorMessageFormatString = "Cannot convert from {0} to {1}.";
        private List<string> items;
 
        public int Capacity { get => items.Capacity; set => items.Capacity = value; }
        public bool IsFixedSize { get => ((IList)items).IsFixedSize; }
        public int Count { get => items.Count; }
        public bool IsReadOnly { get => ((IList<string>)items).IsReadOnly; }
        public bool IsSynchronized { get => ((ICollection)items).IsSynchronized; }
        public string this[int index] { get => items[index]; set => items[index] = value; }
        object IList.this[int index] { get => ((IList)items)[index]; set => ((IList)items)[index] = value; }
        object ICollection.SyncRoot { get => ((ICollection)items).SyncRoot; }
 
        public StringList()
        {
            items = new List<string>();
        }
 
        public StringList(int capacity)
        {
            items = new List<string>(capacity);
        }
 
        public StringList(IList list)
        {
            if (!(list is IList<string>))
            {
                throw new ArgumentException(
                    String.Format(ConversionErrorMessageFormatString, 
                    list.GetType().ToString(),
                    this.GetType().ToString()), 
                    nameof(list));
            }
            items = list as List<string>;
        }
 
        public StringList(IEnumerable collection)
        {
            if (!(collection is IEnumerable<string>))
            {
                throw new ArgumentException(
                    String.Format(ConversionErrorMessageFormatString, 
                    collection.GetType().ToString(),
                    this.GetType().ToString()), 
                    nameof(collection));
            }
            items = new List<string>(collection as IEnumerable<string>);
        }
 
        public void Add(string item)
        {
            items.Add(item);
        }
 
        int IList.Add(object item)
        {
            return ((IList)items).Add(item);
        }
 
        public void AddRange(IEnumerable collection)
        {
            items.AddRange(collection as IEnumerable<string>);
        }
 
        public int BinarySearch(int index, int count, string item, IComparer comparer)
        {
            return items.BinarySearch(index, count, item, (IComparer<string>)comparer);
        }
 
        public int BinarySearch(string item)
        {
            return items.BinarySearch(item);
        }
 
        public int BinarySearch(string item, IComparer comparer)
        {
            return items.BinarySearch(item, (IComparer<string>)comparer);
        }
 
        public void Clear()
        {
            items.Clear();
        }
 
        public bool Contains(string item)
        {
            return items.Contains(item);
        }
 
        bool IList.Contains(object item)
        {
            return ((IList)items).Contains(item);
        }
 
        public void CopyTo(string[] array)
        {
            items.CopyTo(array);
        }
 
        public void CopyTo(string[] array, int arrayIndex)
        {
            items.CopyTo(array, arrayIndex);
        }
 
        void ICollection.CopyTo(Array array, int arrayIndex)
        {
            ((ICollection)items).CopyTo(array, arrayIndex);
        }
 
        public void CopyTo(int index, string[] array, int arrayIndex, int count)
        {
            items.CopyTo(index, array, arrayIndex, count);
        }
 
        public IEnumerator GetEnumerator()
        {
            return items.GetEnumerator();
        }
        
        IEnumerator<string> IEnumerable<string>.GetEnumerator()
        {
            return items.GetEnumerator();
        }
 
        public StringList GetRange(int index, int count)
        {
            return new StringList(items.GetRange(index, count));
        }
 
        public int IndexOf(string item)
        {
            return items.IndexOf(item);
        }
 
        int IList.IndexOf(object item)
        {
            return ((IList)items).IndexOf(item);
        }
 
        public int IndexOf(string item, int index)
        {
            return items.IndexOf(item, index);
        }
 
        public int IndexOf(string item, int index, int count)
        {
            return items.IndexOf(item, index, count);
        }
 
        public void Insert(int index, string item)
        {
            items.Insert(index, item);
        }
 
        void IList.Insert(int index, object item)
        {
            ((IList)items).Insert(index, item);
        }
 
        public void InsertRange(int index, IEnumerable collection)
        {
            items.InsertRange(index, (IEnumerable<string>)collection);
        }
 
        public int LastIndexOf(string item)
        {
            return items.LastIndexOf(item);
        }
 
        public int LastIndexOf(string item, int index)
        {
            return items.LastIndexOf(item, index);
        }
 
        public int LastIndexOf(string item, int index, int count)
        {
            return items.LastIndexOf(item, index, count);
        }
 
        public bool Remove(string item)
        {
            return items.Remove(item);
        }
 
        void IList.Remove(object item)
        {
            ((IList)items).Remove(item);
        }
 
        public void RemoveAt(int index)
        {
            items.RemoveAt(index);
        }
 
        public void RemoveRange(int index, int count)
        {
            items.RemoveRange(index, count);
        }
 
        public void Reverse()
        {
            items.Reverse();
        }
 
        public void Reverse(int index, int count)
        {
            items.Reverse(index, count);
        }
 
        public void Sort()
        {
            items.Sort();
        }
 
        public string[] ToArray()
        {
            return items.ToArray();
        }
 
        public void TrimExcess()
        {
            items.TrimExcess();
        }
    }