C#•2y ago

Generics without Casting

Is there any possible way to do what the code below is doing with generics, but without the casting?

public interface IItemCollection 
{
    int AddItem<T>(T item);
    T GetItem<T>(int id);
}

public class ItemCollection : IItemCollection {
    private Dictionary<Type, Dictionary<int, object>> _items = new();

    public int AddItem<T>(T item) 
    {
        var dictionary = GetDictionary<T>();
        int next = dictionary.Keys.Max() + 1;
        dictionary.Add(next, item);
        return next;
    }

    public T GetItem<T>(int id) 
    {
        var dictionary = GetDictionary<T>();
        return (T)dictionary[id];
    }

    private Dictionary<int, object> GetDictionary<T>() 
    {
        if (!_items.ContainsKey(typeof(T)))
            _items.Add(typeof(T), new Dictionary<int, object>());
        return _items[typeof(T)];
    }
}

public interface IItemCollection 
{
    int AddItem<T>(T item);
    T GetItem<T>(int id);
}

public class ItemCollection : IItemCollection {
    private Dictionary<Type, Dictionary<int, object>> _items = new();

    public int AddItem<T>(T item) 
    {
        var dictionary = GetDictionary<T>();
        int next = dictionary.Keys.Max() + 1;
        dictionary.Add(next, item);
        return next;
    }

    public T GetItem<T>(int id) 
    {
        var dictionary = GetDictionary<T>();
        return (T)dictionary[id];
    }

    private Dictionary<int, object> GetDictionary<T>() 
    {
        if (!_items.ContainsKey(typeof(T)))
            _items.Add(typeof(T), new Dictionary<int, object>());
        return _items[typeof(T)];
    }
}

public interface IItemCollection 
{
    int AddItem<T>(T item);
    T GetItem<T>(int id);
}

public class ItemCollection : IItemCollection {
    private Dictionary<Type, Dictionary<int, object>> _items = new();

    public int AddItem<T>(T item) 
    {
        var dictionary = GetDictionary<T>();
        int next = dictionary.Keys.Max() + 1;
        dictionary.Add(next, item);
        return next;
    }

    public T GetItem<T>(int id) 
    {
        var dictionary = GetDictionary<T>();
        return (T)dictionary[id];
    }

    private Dictionary<int, object> GetDictionary<T>() 
    {
        if (!_items.ContainsKey(typeof(T)))
            _items.Add(typeof(T), new Dictionary<int, object>());
        return _items[typeof(T)];
    }
}

public interface IItemCollection 
{
    int AddItem<T>(T item);
    T GetItem<T>(int id);
}

public class ItemCollection : IItemCollection {
    private Dictionary<Type, Dictionary<int, object>> _items = new();

    public int AddItem<T>(T item) 
    {
        var dictionary = GetDictionary<T>();
        int next = dictionary.Keys.Max() + 1;
        dictionary.Add(next, item);
        return next;
    }

    public T GetItem<T>(int id) 
    {
        var dictionary = GetDictionary<T>();
        return (T)dictionary[id];
    }

    private Dictionary<int, object> GetDictionary<T>() 
    {
        if (!_items.ContainsKey(typeof(T)))
            _items.Add(typeof(T), new Dictionary<int, object>());
        return _items[typeof(T)];
    }
}

DaVinki•1/25/24, 6:16 PM

Use T for the dictionary instead of object

DDaVinki Use T for the dictionary instead of object

CamsterOP•1/25/24, 6:17 PM

But the class ItemCollection isn't generic, only the methods.

Jimmacle•1/25/24, 6:35 PM

i don't think there's a way around it

CamsterOP•1/25/24, 6:38 PM

I had a feeling

CCamster But the class ItemCollection isn't generic, only the methods.

mtreit•1/25/24, 7:10 PM

So make it generic

mtreit•1/25/24, 7:14 PM

Something like this instead:

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

public interface IItemCollection<T>
{
    int AddItem(T item);
    T GetItem(int id);
}

public class ItemCollection<T> : IItemCollection<T>
{
    private Dictionary<Type, Dictionary<int, T>> _items = new();

    public int AddItem(T item)
    {
        var dictionary = GetDictionary();
        int next = dictionary.Keys.Max() + 1;
        dictionary.Add(next, item);
        return next;
    }

    public T GetItem(int id)
    {
        var dictionary = GetDictionary();
        return dictionary[id];
    }

    private Dictionary<int, T> GetDictionary()
    {
        if (!_items.ContainsKey(typeof(T)))
        {
            _items.Add(typeof(T), new Dictionary<int, T>());
        }

        return _items[typeof(T)];
    }
}

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

public interface IItemCollection<T>
{
    int AddItem(T item);
    T GetItem(int id);
}

public class ItemCollection<T> : IItemCollection<T>
{
    private Dictionary<Type, Dictionary<int, T>> _items = new();

    public int AddItem(T item)
    {
        var dictionary = GetDictionary();
        int next = dictionary.Keys.Max() + 1;
        dictionary.Add(next, item);
        return next;
    }

    public T GetItem(int id)
    {
        var dictionary = GetDictionary();
        return dictionary[id];
    }

    private Dictionary<int, T> GetDictionary()
    {
        if (!_items.ContainsKey(typeof(T)))
        {
            _items.Add(typeof(T), new Dictionary<int, T>());
        }

        return _items[typeof(T)];
    }
}

mtreit•1/25/24, 7:14 PM

Note that this code isn't thread safe.

Jimmacle•1/25/24, 7:15 PM

i think the point is that the outer collection isn't generic

Jimmacle•1/25/24, 7:15 PM

it's more like a bag of objects grouped by type

Jimmacle•1/25/24, 7:15 PM

not really sure what the goal is

mtreit•1/25/24, 7:16 PM

Yes, not really clear.

CamsterOP•1/25/24, 7:18 PM

I basically have several objects where I want to manually create Id's for. With them all being different types, I'd like to have one class to do it. But I suppose it's not too bad just to create a generic class similar to @mtreit, and I can create an implementation for each type. Thanks for your help

deprecatio•1/25/24, 9:13 PM

can i say that this int next = dictionary.Keys.Max() + 1;int next = dictionary.Keys.Max() + 1; is a bit awkward

Ddeprecatio can i say that this `int next = dictionary.Keys.Max() + 1;` is a bit awkward

CamsterOP•1/25/24, 9:16 PM

Yes you can! How would you do it?

deprecatio•1/26/24, 7:10 AM

it depends what this thing it has to be
but at least i would just keep an autoincrement id as a field of the class
so that there's no need to duplicate and examine all the keys of the dictionary to get a value

Ddeprecatio it depends what this thing it has to be but at least i would just keep an autoin...

CamsterOP•1/26/24, 5:03 PM

Thanks for the tips. In retrospect, I was thinking along similar lines. In fact, Max() causes an exception when the are no values

CamsterOP•1/26/24, 5:03 PM

In my particular case, there won't be very many items added, so I wasn't too worried about performance.

deprecatio•1/26/24, 8:55 PM

i can understand that, but to me it's kind of a yellow flag
i could maybe accept that if say there was an exception when trying add more than 10~15 items, for example
like throw new Exception("don't use this class for large collections")throw new Exception("don't use this class for large collections")

CamsterOP•1/26/24, 11:51 PM

Oh I'll definitely go the route of having an autoincrement id. I agree it's better. I was mainly trying to figure out if there's a generics trick I wasn't aware of. Thanks for your input

Generics without Casting

Similar Threads

Similar Threads

Similar Threads