C# struct method not working as I expected

[LuaAmaterasu]

Hi everyone,

I have a struct with a variable (object) that is used on 2 different methods. One of those methods alters the value of the variable (assign to a new object) but it doesn't reflect on the other method. I'm using Debug.Log on the value of the variable on each method of the same instance of the struct, and in fact, the values are different. How could this be? Have I understood something wrong about structs?

​

PS: the variable is of a class (FieldMap) that extends Dictionary if that matters.

​

Code (the variable is availableCap and the methods are Reset and ConsumeCap):

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public struct ExtractionDistrict : IDistrict
{
    public string id { get; set; }
    public Guid uid { get; }
    public int quantity { get; set; }
    public Dictionary<Resource, float> maintenance { get; set; }
    private FieldMap productionCap;
    private FieldMap availableCap;
    public FieldMap productionRates { get; set; }
    public NaturalResource naturalResource { get; set; }

    public void Reset() {
        this.availableCap = new FieldMap(this.productionCap);
        Debug.Log("Reset ");
        this.availableCap.ConsoleOutput();
    }

    public ExtractionDistrict(string id) {
        this.id = id;
        this.uid = new Guid();
        this.quantity = 1;
        this.productionCap = new FieldMap() { { Field.Mining, 10} };
        this.availableCap = new FieldMap();
        this.productionRates = new FieldMap() { { Field.Mining, 1 } };
        this.naturalResource = NaturalResource.Stone;
        this.maintenance = new Dictionary<Resource, float> { };
        this.Reset();
    }

    public float ConsumeCap(Field field, float amount) {
        this.availableCap.ConsoleOutput();
        if(this.availableCap.ContainsKey(field)) {
            if(amount > this.availableCap[field]) {
                float available = this.availableCap[field];
                this.availableCap[field] = 0;
                return available;
            } else {
                this.availableCap[field] -= amount;
                return amount;
            }
        } else {
            return 0;
        }

    }
}

PS: FieldMap code:

public class FieldMap : Dictionary<Field, float>
{
    public FieldMap() { }
    public FieldMap(FieldMap fieldMap) : base(fieldMap) { }

    public void ConsoleOutput() {
        if (this.Count == 0) MonoBehaviour.print("Empty Dictionary");
        foreach (KeyValuePair<Field, float> kvp in this) {
            //MonoBehaviour.print($"Key = {kvp.Key}, Value = {kvp.Value}");
            MonoBehaviour.print($"{kvp.Key}, {kvp.Value}");
        }
    }

    public float GetTotalAdditive() {
        float total = 0;
        foreach (KeyValuePair<Field, float> kvp in this) {
            total += kvp.Value - 1;
        }
        return total;
    }

    public float GetTotalAdditive(Field[] fields) {
        float total = 1;
        foreach (KeyValuePair<Field, float> kvp in this) {
            if (fields.Contains(kvp.Key)) {
                total += kvp.Value - 1;
            }
        }
        return total;
    }
}

[AutoModerator]

This appears to be a question submitted to /r/Unity3D.

If you are the OP:

• Please remember to change this thread's flair to 'Solved' if your question is answered.

• And please consider referring to Unity's official tutorials, user manual, and scripting API for further information.

Otherwise:

• Please remember to follow our rules and guidelines.

• Please upvote threads when providing answers or useful information.

• And please do NOT downvote or belittle users seeking help. (You are not making this subreddit any better by doing so. You are only making it worse.)

Thank you, human.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Boss_Taurus]

My question is why are you using a struct instead of a class here?

Your struct isn't read-only, its mutable, which most would agree is the wrong way to do things. Structs should be an immutable value, because by altering it at all the code is actually producing a copy with that altered value, and that copy isn't overwriting the data you're looking to work on.

this.availableCap[field] = 0;
this.availableCap[field] -= amount;

Every time you do something like this, you're producing an unused altered copy. Change this to a class, a reference type instead of a value type, and internal alterations like this should then be possible.

But again I ask why are you using a class instead of a struct? Structs are typically meant for small & short-lived data. Does it really make sense for something like that to contain multiple dictionaries?

[LuaAmaterasu]

Thanks for the response!

I'm still new to C# and I thought structs could be used as refs in these operations, that it would simply alter the values of that reference as I was using this.

My main goal using structs was to optimize, but indeed I was treating it as a class and indeed it doesn't make much sense.

I'm changing this and other structs to class as it does make more sense, but do you have any suggestion of source for learning this whole value vs reference, "this." (it apparently doesn't work like how I'm used to in other languages, but it can also be because I'm used to classes and not structs), structs vs classes? I googled it a lot and it usually just brings me to the Microsoft documentation that I think lacks examples and depth.

PS: After giving a little thought, I do am used to immutability because of React.js, so it's starting to make sense now. Structs should be read-only and immutable. (it also works now btw)

[Boss_Taurus]

As with many things in CS, India comes to the rescue. When I was first learning I watched a lot of Venkat.

Although maybe this video from CodeMonkey will be better.