Hey guys. I'm working in XNA.

I'm basically trying to have a Data/Asset Manager class that holds everything that's loaded in by the ContentManager.

I'm trying to have a property that's essentially something along the lines of

Dictionary<T, Dictionary<string, T>> listOfObjects;

My hope is to be able to get objects doing something like

Texture2D texture = listOfObjects<Texture2D>("nameOfTexture");

SpriteFont font = listOfObjects<SpriteFont>("nameOfFont");

// etc. 

Any help and / or suggestions? Thank you so much in advance

My initial implementation is in fact having multiple dictionaries for each type, which is absolutely fine.

I suppose the reason I wanted it this way was so that the class could be generic enough to be used across projects.

If I required a dictionary of objects using a class that was specific to a particular game, such as a Level class, then the list would be generic enough for me to Add and Get levels, as opposed to adding a new dictionary for Levels which would be specific to a game project.

Does that make sense?

Thank you for your response!

public static class AssetManager
{
  public static Dictionary<string,Texture2D> Textures;
  public static Dictionary<string,SpriteFont> Fonts;
}
 
elsewhere:
{
  var texture = AssetManager.Textures["nameOfTexture"];
}

public static class AssetManager
{
  static Dictionary<Type,object> dict;

  T GetAssetByType<T>(string key) where T:class
  {
    object o;
    if (dict.TryGetValue(typeof(T), out o))
    {
      var nestedDict = o as Dictionary<string,T>;
      if (nestedDict != null)
        return nestedDict[key];
    }    

    return null;
  }
}

elsewhere:
{
  var texture = AssetManager.GetAssetByType<Texture2D>("nameOfTexture");
}

public static class AssetManager<T> where T:class // or the base class of XNA assets, if you want
{
  public static Dictionary<string,T> Assets;
}

elsewhere:
{
  var texture = AssetManager<Texture2D>.Assets["nameOfTexture"];
}

What's your end goal exactly?

My hope is to be able to get objects doing something like


Texture2D texture = listOfObjects<Texture2D>("nameOfTexture");

SpriteFont font = listOfObjects<SpriteFont>("nameOfFont");

// etc.

That's exactly what XNA's ContentManager does.

Texture2D texture = Content.Load<Texture2D>("nameOfTexture");

SpriteFont font = Content.Load<SpriteFont>("nameOfFont");

Why not just use that?

The ContentManager is used to Load objects, not get them once they've been loaded. I don't think I'd be creating new variables for each and every texture and so on. A Dictionary seems more appropriate.

As for the generic solution I was after, I've come up with this:

        Dictionary<Type, object> dict;

        public void Add<T>(string key, T value)
        {
            Type type = typeof(T);
            bool dictContainsKey = dict.ContainsKey(type);

            if (!dictContainsKey)
                dict.Add(type, new Dictionary<string, T>());

            Dictionary<string, T> nestedDict = dict[type] as Dictionary<string, T>;

            if (nestedDict.ContainsKey(key))
                nestedDict[key] = value;
            else
                nestedDict.Add(key, value);
        }

        public T Get<T>(string key)
        {
            Type type = typeof(T);
            bool dictContainsKey = dict.ContainsKey(type);

            if (!dictContainsKey)
                return default(T);

            Dictionary<string, T> nestedDict = dict[type] as Dictionary<string, T>;

            if (nestedDict.ContainsKey(key))
                return nestedDict[key];
            else
                return default(T);
        }

What are your thoughts - is this a bad / unnecessary implementation?

Admittedly it's a little messy, and probably unnecessary. For whatever reason I felt a single Dictionary with all assets is the way to go. My plan was to then write getters and setters and so on for accessing specific types, such as GetTexture(string key) { return // ... gets Texture2D from nested dictionary in dict }

Anyway, I guess having Dictionaries for each type seems to be a more suitable and cleaner solution.

Thanks everybody for your input.

Personally i use somthing like this:

public Dictionary<string, object> _AssetDictionary;


public void LoadAssets()
{
    _AssetDictionary = new Dictionary<string, object>();
    _AssetDictionary.Add("FONT_MENUFONT", LoadSpritefont(MenuFont));
    _AssetDictionary.Add("ASSET_AWESOMETEXTURE", LoadTexture(MenuFont));
}
public T Get<T> GetAsset(string name)
{
    return (T)_AssetDictionary[name];
}

//Reference with
GetAsset<Texture2D>("ASSET_AWESOMETEXTURE");

ofc string can be replaced with anything, even object :P so you have have it stored by different enum values.

There are many ways to expand on this, but strings suffice for most things.