C#

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;
        }
    }
}

private void textBoxTT_KeyPress(object sender, KeyPressEventArgs e)
       {
           if (!char.IsDigit(e.KeyChar))
               e.Handled = true;
           return;
       }