C#

// Step 1 State
class MyInfo {
    public InfoData? Info; 
}

// Step 2 State
class MyInfo {
    public InfoData Info;
}

class MyInfo {
    private _infoData?;
    public InfoData {
        get => _infoData ?? throw ...
        set => _infoData = value
    }
}

class MyInfo {
   public InfoData = InfoData.Empty;

   public static InfoData Empty => new InfoData(); 
}

private void M2_SaidaEfetiva_Click(object sender, EventArgs e)
        {
            if (FormEfetivas == null)
            {
                FormEfetivas = new Frm_Saida();
                FormEfetivas.MdiParent = this;
                FormEfetivas.Text = "Saídas Efetivas";
                FormEfetivas.Tag = "1";
                FormEfetivas.Show();
            }
            FormEfetivas.Activate();
        }
        private void M2_SaidaPrevisao_Click(object sender, EventArgs e)
        {
            if (FormPrevisao == null)
            {
                FormPrevisao = new Frm_Saida();
                FormPrevisao.MdiParent = this;
                FormPrevisao.Text = "Previsão de Saídas";
                FormPrevisao.Tag = "0";
                FormPrevisao.Show();
            }

public class FileAttachment
{
    // other FileAttachment class stuff 
	
    protected void AuthorizeFileAccess(FileAttachmentData file)
    {
        // file has a field which tells which entity it relates to
        // here I need to choose which class to use based on the file data
    }
}


// simplified example of related entity
public class ChatMessage
{
	public int SenderUserId;
	public int RecipientUserId;
	
	// here I need a method that checks that chat message sender's or recipient's
	// user id matches the user id of the logged in user
	// if not, throw exception
}

BeingCache cache = BeingCache.CacheInstance;

Human ahuman = new Human("joe", "male");
Cat acat = new Cat("Meow", true);

IBeing b1 = cache[1]; // works

IBeing<Cat> b2 = (IBeing<Cat>) b1; // works

Cat cat = b2.IBInstance; // works

bool st0 = b2 is Cat; // false

bool st1 = b2 is Being<Cat>; // true

bool st2 = b2 is IBeing<Cat>; // true

Cat hepcat = BeingCache.GetBeing<Cat>(cache[1]); // works

IBeing<Cat> b3 = (IBeing<Cat>) cache[1]; // works

using System;
using System.Collections.Generic;

namespace InterfaceInheritance_2020
{
    public class Human
    {
        public Human(string name, string gender)
        {
            Name = name;
            Gender = gender;

            BeingCache.SetCache(this); //  :wtf: 
        }

        public string Gender{ get;}
        public string Name { get; }
    }

    public class Cat
    {
        public Cat(string name, bool haswhiskers = true)
        {
            Name = name;
            HasWhiskers = haswhiskers;

            BeingCache.SetCache(this); //  :wtf: 
        }

        public bool HasWhiskers { get; }
        public string Name { get; }
    }

    public interface IBeing
    {
        Type BeingType { set; get; }
    }

    public interface IBeing<T> : IBeing
    {
        T IBInstance { set; get; }
    }

    public class Being<T> : IBeing<T>
    {
        public Being(T content)
        {
            IBInstance = content;
            BeingType = typeof(IBeing<T>);
        }

        public Type BeingType { get; set; }
        public T IBInstance { get; set; }
    }

    //singleton 
    public sealed class BeingCache : List<IBeing>
    {
        private BeingCache()
        {
        }

        public static BeingCache CacheInstance{ get; } = new BeingCache();

        public static void SetCache<T>(T value)
        {
            CacheInstance.AddBeing(new Being<T>(value), typeof(T));
        }

        public void AddBeing(IBeing being, Type btype)
        {
            being.BeingType = btype;
            CacheInstance.Add(being);
        }

        public static T GetBeing<T>(IBeing being)
        {
            return (T) ((IBeing<T>) being).IBInstance;
        }
    }
}