Simple item and inventory system

Question

Items.cs, Creates dictionaries, enumerators, and classes for every type of item.

using System;
using System.Collections.Generic;
public class Item {
 // Medical
 public static Dictionary < Medical, ItemMedical > Medicals = new Dictionary<Medical, ItemMedical>() {
 { Medical.bandage, new ItemMedical() { name = "bandage", healing = 15, weight = 0.2f, value = 75, description =
 "Simple bandage to dress minor injuries. For patching up boo boos when you fall off your bicycle, won't save you from a gunshot." }},
 { Medical.tourniquet, new ItemMedical() { name = "tourniquet", healing = 25, weight = 0.7f, value = 225, description =
 "A device that tightly wraps around a limb near the wound to stop the flow of blood, more importantly, it stops blood from flowing OUT." }}
 };
 // Weapon
 public static Dictionary < Weapon, ItemWeapon > Weapons = new Dictionary < Weapon, ItemWeapon > () {
 { Weapon.shortsword, new ItemWeapon() { name = "shortsword", Damage = 25, weight = 4, value = 750, description =
 "A relatively short sword, hence the very creative name \"Shortsword\"." }}, 
 { Weapon.longsword, new ItemWeapon() { name = "longsword", Damage = 40, weight = 6, value = 950, description = 
 "A relatively long sword, hence the very creative name \"Longsword\"." }}
 };
 // Armor
 public static Dictionary < Armor, ItemArmor > Armors = new Dictionary < Armor, ItemArmor > () {
 { Armor.police_vest, new ItemArmor() { name = "police vest", Resistance = 25, Durability = 15, weight = 5, value = 1200, description =
 "A pistol grade body armor used by police forces." }},
 { Armor.military_vest, new ItemArmor() { name = "military vest", Resistance = 60, Durability = 40, weight = 8, value = 2400, description =
 "A heavy military vest capable of withstanding some rifle rounds." }}
 };
 public static ItemMedical Get(Medical key) => Medicals[key];
 public static ItemWeapon Get(Weapon key) => Weapons[key];
 public static ItemArmor Get(Armor key) => Armors[key];
}
public enum Medical {
 bandage,
 tourniquet
}
public enum Weapon {
 shortsword,
 longsword
}
public enum Armor {
 police_vest,
 military_vest
}
public class ItemMedical: ItemBase {
 public float healing = 0;
}
public class ItemWeapon: ItemBase {
 private float damage = 0;
 public float Damage {
 get => damage;
 set => damage = value;
 }
}
public class ItemArmor: ItemBase {
 // Damage required to penetrate armor
 public float Resistance = 0;
 // "health" of the armor, damaged much more if penetrated
 private float durability = 0;
 public float Durability {
 get => durability;
 set => durability = Math.Clamp(value, 0, value);
 }
}
public class ItemBase {
 public string name = "No name";
 public string description = "No description";
 public float weight = 0;
 public float value = 0;
}

Inventory.cs, equipment is an array because the slots never change, but backpack is a list because i dont know how many items will be in there.

 public static ItemBase[] equipment = new ItemBase[4] {
 // Primary weapon
 Item.Get(Weapon.longsword),
 // Secondary weapon
 Item.Get(Weapon.shortsword),
 // Body armor
 Item.Get(Armor.police_vest),
 // Rig
 null
 };
 public static List<ItemBase> backpack = new List<ItemBase>() {
 Item.Get(Medical.bandage),
 Item.Get(Medical.bandage),
 };
}

Usage

class Program {
 static void Main(string[] args) {
 Console.WriteLine("Items in inventory:");
 foreach(ItemBase item in Inventory.equipment) {
 if (item != null) Console.WriteLine(item.name);
 else Console.WriteLine("Nothing");
 }
 Console.WriteLine("\nItems in backpack:");
 foreach(ItemBase item in Inventory.backpack) {
 Console.WriteLine(item.name);
 }
 }
}

Output:

Items in inventory: longsword shortsword police vest Nothing

Items in backpack: bandage bandage

My first actually competant looking piece of code as a beginner. Really proud of it.

Answer 1

First of all, congratulation it is a great first attempt. Even though it does not contain too much functionality rather structure and data.

Most of my recommendation will be related to C# coding conventions. Some of my suggestions are taking advantage of C# 9's new features so I'll share some links about them.

Enums

public enum Medical { Bandage, Tourniquet }
public enum Weapon { ShortSword, LongSword }
public enum Armor { PoliceVest, MilitaryVest }

• In C# we usually use PascalCasing for enum members
  • In your Weapon enum you have used lower casing
  • whereas in your Armor enum you have used snake_casing
  • Please try to chase consistency across your domain model
• Most of the time when the enum contains less than 5 members (and they are not overwriting default values) C# developers tend to define the enum in a single line

Base class

public abstract class ItemBase
{
 public string Name { get; init; } = "No name";
 public string Description { get; init; } = "No description";
 public float Weight { get; init; }
 public float Value { get; init; }
}

• This class is used to define common properties that's why it is advisable to mark it as abstract
  • That prevents the consumer of this class to instantiate an object from it
  • You want to allow to be able to create only derived classes
• C# developers are preferring properties over fields whenever they are public
  • That's why I've changed all the base class members to properties
  • I've also changed their name since in C# we normally use Pascal Casing for properties
  • I've used init instead of set, because it only allows initialization (via constructor or via object initializer)
    • So, after an item is created with a specified values it can't be changed later on
  • Since C# 6 you can define default value for auto generated fields

Derived classes

public class ItemMedical : ItemBase
{
 public float Healing { get; init; }
}
public class ItemWeapon : ItemBase
{
 public float Damage { get; init; }
}
public class ItemArmor : ItemBase
{
 public float Resistance { get; init; }
 private float durability;
 public float Durability
 {
 get => durability;
 set => durability = Math.Clamp(value, 0, value);
 }
}

• Please prefer auto-generated properties over manually creating backing fields and defining getter and setter methods
  • The only exception is whenever you have custom logic either inside the getter or inside the setter (like Durability)
• I've get rid of the = 0 initial value assignments since these are their default values

The Item class #1

This constant data class can be implemented in several ways. One way to achieve it as you have done it.

• In this case you can mark the class itself as static since all of its member is static as well
• If you expose the dictionaries (public) then you should consider to make them immutable to prevent further element removal or addition after intialization

public static class Item
{
 public static readonly ImmutableDictionary<Medical, ItemMedical> Medicals = new Dictionary<Medical, ItemMedical>
 {
 {
 Medical.Bandage,
 new()
 {
 Name = "bandage",
 Healing = 15,
 Weight = 0.2f,
 Value = 75,
 Description = "Simple bandage to dress minor injuries. For patching up boo boos when you fall off your bicycle, won't save you from a gunshot."
 }
 },
 {
 Medical.Tourniquet,
 new()
 {
 Name = "tourniquet",
 Healing = 25,
 Weight = 0.7f,
 Value = 225,
 Description = "A device that tightly wraps around a limb near the wound to stop the flow of blood, more importantly, it stops blood from flowing OUT."
 }
 }
 }.ToImmutableDictionary();
 ...
 public static ItemMedical Get(Medical key) => Medicals[key];
 public static ItemWeapon Get(Weapon key) => Weapons[key];
 public static ItemArmor Get(Armor key) => Armors[key];
}

• I've marked the collections as readonly to prevent overwriting with another collection or null by the consumer of the class
• I've used new() (target typed new expression) to avoid repeating the class names over and over again
  • It can be inferred from the Dictionary type parameter

The Item class #2

Let me show you an alternative approach:

public class Item
{
 private static readonly Lazy<Item> singleton = new Lazy<Item>(new Item());
 public static Item Instance => singleton.Value;
 private Item() { }
 private readonly Dictionary<Medical, ItemMedical> Medicals = new ()
 {
 {
 Medical.Bandage,
 new ()
 {
 Name = "bandage",
 Healing = 15,
 Weight = 0.2f,
 Value = 75,
 Description = "Simple bandage to dress minor injuries. For patching up boo boos when you fall off your bicycle, won't save you from a gunshot."
 }
 },
 {
 Medical.Tourniquet,
 new ()
 {
 Name = "tourniquet",
 Healing = 25,
 Weight = 0.7f,
 Value = 225,
 Description = "A device that tightly wraps around a limb near the wound to stop the flow of blood, more importantly, it stops blood from flowing OUT."
 }
 }
 };
 ...
 public ItemMedical this[Medical key] => Medicals[key];
 public ItemWeapon this[Weapon key] => Weapons[key];
 public ItemArmor this[Armor key] => Armors[key];
}

• Here I've made the dictionaries private so they became implementation details
• I've replaced the Get methods to index operators to make the item retrieval a bit more convenient
  • See next section for usage
  • The index operators can't be defined as static so we have to make a little trick here to make the usage easy
• We use the singleton pattern to expose a single instance to the consumers of the class
  • Here I've implemented this pattern with a Lazy to make sure that the instance is created only when it is first accessed but in a thread safe manner

These changes allow us to define the Equipments and Backpack like this:

public ItemBase[] Equipments = new []
{
 Item.Instance[Weapon.LongSword],
 Item.Instance[Weapon.ShortSword],
 Item.Instance[Armor.PoliceVest],
 (ItemBase)null
};
public List<ItemBase> Backpack = new ()
{
 Item.Instance[Medical.Bandage],
 Item.Instance[Medical.Bandage],
};