Wsrtjtyk

I am making a utility library for various .Net Framework datastructures in C#. I am trying to add ICloneable to Dictionary<>. Is there a way to do this through an extension, like how you make extension methods?

To clarify further, in C# you can extend from already existing classes by making "Extension Methods" in a static class, like so:

public static class MyExtensions

{

    public static void MyArrayExtension<T>(this T arg)

    {

        //Your code here...

    }

}

This allows you to do the function on all arrays, like so:

MyArray.MyArrayExtension();

You can create extension methods to extend all classes and structs, including those that you reference in DLLs like those for the .Net Framework. I am using this currently to help me design a utility library, with tons of useful extensions that I feel should have been implemented in C# in the first place.

When looking at System.Linq, it appears that Interfaces are somehow added to certain datastructure classes like Array and List<>, but only when the namespace is included. I am trying to figure out how this is done, as I cannot find any examples after searching online.

As of now, this is not possible.

You can add the requisite Clone extension methods, but there is no way right now to tuck on a whole interface.

Remember that checking for support for an interface could be written in existing code like this:

if (dictionary is ICloneable cloneable)

    var clone = cloneable.Clone();

But this would not work with just extension something as the underlying type does not in fact implement the interface.

There are some ongoing efforts in this line of thought:

• Extension everything


• Shapes

I have no idea how good they manage to get these things so whether it could potentially solve this in the future is a bit up in the air.

Note that you could do this using decoration, but it might be a bit of work and it would require you to construct your dictionaries using a different type:

public class CloneableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, ICloneable

{

    ... methods and properties that delegate to base.XYZ



    public object Clone() => new ...

}

Everywhere you construct your object you would then have to write this:

var dictionary = new CloneableDictionary<...>();

instead of:

var dictionary = new Dictionary<...>();

Since CloneableDictionary inherits Dictionary, you could drop it into variables and parameters that already exists, even if their type is kept as Dictionary<...>, but if you forget that you're really storing other dictionary types in there and construct new, normal, non-cloneable, dictionaries some places it may quickly fall down.