❔ Create new instance of type unknown at runtime?

Shillelagh · 2023-08-01T22:30:21.970Z

Say I have a base class, ``abstract class Letter`` with child classes ``A``, ``B``, and ``C``. If I have a variable: ``Letter myLetter`` which is of unknown type (can be any of ``A``, ``B``, or ``C``, the only guarantee is it's a child of ``Letter``), how can I create a new instance of whatever class ``myLetter`` is? I need to create a new instance (must call default constructor as well) of whatever ``myLetter`` is and store it in another variable (say ``myLetter2``)

A

Angius•8/1/23, 10:36 PM

So, basically,

Letter myLetter = new B();
var thing = CreateInstanceOfWhateverTypeTheVariableIs(myLetter);
thing is B // true

Letter myLetter = new B();
var thing = CreateInstanceOfWhateverTypeTheVariableIs(myLetter);
thing is B // true

Letter myLetter = new B();
var thing = CreateInstanceOfWhateverTypeTheVariableIs(myLetter);
thing is B // true

Letter myLetter = new B();
var thing = CreateInstanceOfWhateverTypeTheVariableIs(myLetter);
thing is B // true

?

S

ShillelaghOP•8/1/23, 10:37 PM

Yes

A

Angius•8/1/23, 10:39 PM

Not gonna lie, I wonder why you'd need to do that, but aight

A

Angius•8/1/23, 10:39 PM

The one and only way I can think of is reflections

S

ShillelaghOP•8/1/23, 10:39 PM

Ah, I figured

A

Angius•8/1/23, 10:40 PM

Activator.CreateInstance(myLetter.GetType())

Activator.CreateInstance(myLetter.GetType())

Activator.CreateInstance(myLetter.GetType())

Activator.CreateInstance(myLetter.GetType()) should work

M

MODiX•8/1/23, 10:41 PM

Angius

REPL Result: Success

class Letter {}
class B : Letter {}

Letter l = new B();
var x = Activator.CreateInstance(l.GetType());

x is B

class Letter {}
class B : Letter {}

Letter l = new B();
var x = Activator.CreateInstance(l.GetType());

x is B

class Letter {}
class B : Letter {}

Letter l = new B();
var x = Activator.CreateInstance(l.GetType());

x is B

class Letter {}
class B : Letter {}

Letter l = new B();
var x = Activator.CreateInstance(l.GetType());

x is B

Result: bool

True

True

True

True

Compile: 531.005ms | Execution: 44.365ms | React with ❌ to remove this embed.

A

Angius•8/1/23, 10:41 PM

Yeah, seems to work file

AAngius Not gonna lie, I wonder why you'd need to do that, but aight

S

ShillelaghOP•8/1/23, 10:41 PM

Wondering as well if there was another way. In reality I have a reagent clasd which stores properties of the reagent including amount. When I move reagent from one container to another I need to remove the correct quantity from one container (changing its amount variable) and then add a new reagent instance of whatever type the reagent instance is from the first container, set the amount properly and store it I another container

A

Angius•8/1/23, 10:43 PM

Uh, ca't you just do

containerOne.Reagents.Add(containerTwo.Reagents[0]);
containerTwo.RemoveAt(0);

containerOne.Reagents.Add(containerTwo.Reagents[0]);
containerTwo.RemoveAt(0);

containerOne.Reagents.Add(containerTwo.Reagents[0]);
containerTwo.RemoveAt(0);

containerOne.Reagents.Add(containerTwo.Reagents[0]);
containerTwo.RemoveAt(0);

?

J

JP•8/1/23, 10:43 PM

So you have

ContainerA | Reagent1(30mg)
ContainerB | --

ContainerA | Reagent1(30mg)
ContainerB | --

ContainerA | Reagent1(30mg)
ContainerB | --

ContainerA | Reagent1(30mg)
ContainerB | --

And you need to be able to represent a change of state to:

ContainerA | Reagent1(10mg)
ContainerB | Reagent1(20mg)

ContainerA | Reagent1(10mg)
ContainerB | Reagent1(20mg)

ContainerA | Reagent1(10mg)
ContainerB | Reagent1(20mg)

ContainerA | Reagent1(10mg)
ContainerB | Reagent1(20mg)

Correct?

AAngius Uh, ca't you just do ```cs containerOne.Reagents.Add(containerTwo.Reagents[0]); ...

S

ShillelaghOP•8/1/23, 10:44 PM

If I move 100% of the reagent yes, otherwise a new reagent instance is necessary.

JJP So you have ``` ContainerA | Reagent1(30mg) ContainerB | -- ``` And you need to ...

S

ShillelaghOP•8/1/23, 10:44 PM

Yes

J

JP•8/1/23, 10:44 PM

This sounds like your reagents should not be C# types

S

ShillelaghOP•8/1/23, 10:45 PM

Wuh oh

J

JP•8/1/23, 10:45 PM

I'd have one Reagent type, which has an enum value-ed member

ReagentType

ReagentType

ReagentType

ReagentType, and an amount.

A

Angius•8/1/23, 10:45 PM

Or should be stored differently, although maybe I'm thinking too much in database terms to be introducing many-to-many lol

J

JP•8/1/23, 10:49 PM

what happens if you put 2 of the same reagent into a container?

S

ShillelaghOP•8/1/23, 10:52 PM

Whenever a reagent is added a method,

CombineLikeReagents()

CombineLikeReagents()

CombineLikeReagents()

CombineLikeReagents() which adds their quantities together

J

JP•8/1/23, 10:55 PM

my quick sketch, might be useful, might not be. It's here :P

public enum ReagentType
{
    VeryCoolSubstance,
    KindaInterestingSubstance,
    SpookySubstance,
}

public class Reagent
{
    public required ReagentType Type { get; init; }
    public double VolumeMl { get; init; }
}

public class Container
{
    private readonly Dictionary<ReagentType, Reagent> _contents = new();
    
    public void Add(Reagent reagent)
    {
        if (_contents.TryGetValue(reagent.Type, out var existing) {
            existing.VolumeMl += reagent.VolumeMl;
        } else {
            _contents.Add(reagent.Type, reagent);
        }
        
    }
}

public enum ReagentType
{
    VeryCoolSubstance,
    KindaInterestingSubstance,
    SpookySubstance,
}

public class Reagent
{
    public required ReagentType Type { get; init; }
    public double VolumeMl { get; init; }
}

public class Container
{
    private readonly Dictionary<ReagentType, Reagent> _contents = new();
    
    public void Add(Reagent reagent)
    {
        if (_contents.TryGetValue(reagent.Type, out var existing) {
            existing.VolumeMl += reagent.VolumeMl;
        } else {
            _contents.Add(reagent.Type, reagent);
        }
        
    }
}

public enum ReagentType
{
    VeryCoolSubstance,
    KindaInterestingSubstance,
    SpookySubstance,
}

public class Reagent
{
    public required ReagentType Type { get; init; }
    public double VolumeMl { get; init; }
}

public class Container
{
    private readonly Dictionary<ReagentType, Reagent> _contents = new();
    
    public void Add(Reagent reagent)
    {
        if (_contents.TryGetValue(reagent.Type, out var existing) {
            existing.VolumeMl += reagent.VolumeMl;
        } else {
            _contents.Add(reagent.Type, reagent);
        }
        
    }
}

public enum ReagentType
{
    VeryCoolSubstance,
    KindaInterestingSubstance,
    SpookySubstance,
}

public class Reagent
{
    public required ReagentType Type { get; init; }
    public double VolumeMl { get; init; }
}

public class Container
{
    private readonly Dictionary<ReagentType, Reagent> _contents = new();
    
    public void Add(Reagent reagent)
    {
        if (_contents.TryGetValue(reagent.Type, out var existing) {
            existing.VolumeMl += reagent.VolumeMl;
        } else {
            _contents.Add(reagent.Type, reagent);
        }
        
    }
}

JJP my quick sketch, might be useful, might not be. It's here :P ```csharp public e...

S

ShillelaghOP•8/1/23, 11:02 PM

Nice. Yes what I have going on is very similar. My previous version used a class in place of an enum (since different reagents have special properties) but was otherwise identical. Previously all combining was done in an addreagent method as well, but I never made on for the slightly newer version

J

JP•8/1/23, 11:03 PM

have special properties

What do these properties look like? (Literal C# properties?)

S

ShillelaghOP•8/1/23, 11:04 PM

No, methods that define how a reagent might react with another. The base class has a react method, overridden by a child.

J

JP•8/1/23, 11:05 PM

Aha, I think I have the solution

J

JP•8/1/23, 11:05 PM

one moment, sketching

J

JP•8/1/23, 11:08 PM

Each reagent can be responsible for creating the new one:

public abstract class Reagent
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);
    public abstract Reagent Take(double volumeMl);
}

public class Substance1 : Reagent
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }

    public override Reagent Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new Substance1
        {
            VolumeMl = volumeMl,
        };
    }
}

public abstract class Reagent
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);
    public abstract Reagent Take(double volumeMl);
}

public class Substance1 : Reagent
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }

    public override Reagent Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new Substance1
        {
            VolumeMl = volumeMl,
        };
    }
}

public abstract class Reagent
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);
    public abstract Reagent Take(double volumeMl);
}

public class Substance1 : Reagent
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }

    public override Reagent Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new Substance1
        {
            VolumeMl = volumeMl,
        };
    }
}

public abstract class Reagent
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);
    public abstract Reagent Take(double volumeMl);
}

public class Substance1 : Reagent
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }

    public override Reagent Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new Substance1
        {
            VolumeMl = volumeMl,
        };
    }
}

S

ShillelaghOP•8/1/23, 11:10 PM

Ah true

S

ShillelaghOP•8/1/23, 11:10 PM

That would work

J

JP•8/1/23, 11:12 PM

If the

Take

Take

Take

Take is always the same for all, can do some generic stuff:

public abstract class Reagent<T> where T : Reagent<T>, new()
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);

    public T Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new T
        {
            VolumeMl = volumeMl,
        };
    }
}

public class Substance2 : Reagent<Substance2>
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }
}

public abstract class Reagent<T> where T : Reagent<T>, new()
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);

    public T Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new T
        {
            VolumeMl = volumeMl,
        };
    }
}

public class Substance2 : Reagent<Substance2>
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }
}

public abstract class Reagent<T> where T : Reagent<T>, new()
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);

    public T Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new T
        {
            VolumeMl = volumeMl,
        };
    }
}

public class Substance2 : Reagent<Substance2>
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }
}

public abstract class Reagent<T> where T : Reagent<T>, new()
{
    public double VolumeMl { get; set; }
    public abstract void React(Reagent other);

    public T Take(double volumeMl)
    {
        this.VolumeMl -= volumeMl;
        return new T
        {
            VolumeMl = volumeMl,
        };
    }
}

public class Substance2 : Reagent<Substance2>
{
    public override void React(Reagent other)
    {
        // some specific reaction logic
    }
}

J

JP•8/1/23, 11:12 PM

alright, I stop spam now haha

S

ShillelaghOP•8/1/23, 11:14 PM

A generic is clever there

S

ShillelaghOP•8/1/23, 11:14 PM

Nw, thanks for the help

A

Accord•8/2/23, 11:26 PM

Was this issue resolved? If so, run

/close

/close

otherwise I will mark this as stale and this post will be archived until there is new activity.