How to code generic class extension operator

Question

3.50/5 (2 votes)

See more:

I am trying to code an extension conversion operator for
System.Collections.Generic.Collection.

The purpose is to convert a collection of T1 types to a collection of T2 types.
I already defined the required set of conversions from T1 to T2.

XML

public static class CollectionExtension
    {
        public static explicit operator Collection<T2>(this Collection<T1> rhs)
            where T1 : class
            where T2 : class, new()
        {
            Collection<T2> lhs = new Collection<T2>();
            // Foreach ...
            return lhs;
        }
    }

I got as far as this by looking at existing posts, but it won't compile.
Could some one please explain how to do this.

Thanks.

Posted 19-Mar-14 4:40am

Member 10167731

Add a Solution

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2014-03-19T05:40:00

The idea is simple: you should provide one more parameter (method parameter, not generic parameter): the delegate instance converting the element of the type T1 to the type T2. Your type constraints for T1 and T2 are absolutely redundant and useless. You can work with elements of any types, not just classes.

Your delegate-type parameter should itself be generic, using the same generic parameters, T1 and T2:

C#

public static class SomeExtensionUtility {

    public static List<T2> ConvertList<T1, T2>(
            this List<T1> list,
            System.Func<T1, T2> convertor) {
        return // please implement it yourself
    }

}

The implementation is simple: you convert elements in source collection to T2 add then to the target collection, one by one, in a loop. I replaced Collection with List just for example, because Collection is probably some your type which I don't have.

By the way, it is not quite clear why did you call your class CollectionExtension :-).
It won't work this way, because you operator, as the operator of the static class, won't compile. But my class can be used as the extension class.

[EDIT]

The usage of this extension method won't be different from any other extension method:

C#

using MyExtensionMethods; // let's assume this is the namespace with SomeExtensionUtility
// let me stay with System.Collections.Generic.List<>, just for example,
// it will be easier to demonstrate:
using System.Collections.Generic;

//...

List<string> stringList = new List<string>();
List<int> intList = stringList.ConvertList<string, int>(
    (stringValue) => { return int.Parse(stringValue); }
);

For some background, please also read:
http://en.wikipedia.org/wiki/Covariance_and_contravariance_%28computer_science%29[^],
http://msdn.microsoft.com/en-us/library/dd799517%28v=vs.110%29.aspx[^].

This covariance/contravariance matter is really non-trivial, but the problem and the solution I demonstrated are trivial enough.

—SA

BillWoodruff · Accepted Answer · 2014-03-19T08:32:00

I think Sergey "got there" first, and gave you the key insight you need; I suggest you accept his answer.

While I am not familiar with the ObjectModel.Collection class, I have written an extension method to convert a Generic List of one Type to a Generic List of another Type:

C#

public static class GenericListExtensions
{
    public static List<T2> ConvertGenericList<T1, T2>(this List<T1> T1List, Func<T1,T2> conversionFunc)
    {
        return T1List.Select(conversionFunc).ToList();
    }
}

An example of usage:

C#

List<int> intList = new List<int>{1,2,3,4,5};

List<string> stringList = intList.ConvertGenericList<int, string>(anInt => anInt.ToString());

Linq and Lambda really allow some useful brevity !

How to code generic class extension operator

2 solutions

Solution 1

Solution 2

Add your solution here

Preview 0