To add winforms support to an .NET class (Windows only) library add <UseWindowsForms>true</UseWindowsForms> to the project file. It will look like something below. (.NET 8.0)

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net8.0-windows</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
   <UseWindowsForms>true</UseWindowsForms>
  </PropertyGroup>
</Project>

In C#, it’s not straightforward to limit access to an inner class from outside its outer class. For instance, if you want to expose an inner class as a property and only allow read access to one of its properties while preventing write access. There are several ways to solve this problem. One method involves using interfaces, which in my opinion, offers a clean solution.

The example below shows how a integer value called MyValue inside MyInnerClass can read publicly but only be set by its outer-class ‘MyOuterClass’.

The code should be self-explanatory.

public class MyOuterClass
{
    //Define the setters to be used in "OuterClass"
    public interface IInnerClass
    {
        //The get will be provided by MyInnerClass,
        //no need to implement it in the interface
        int MyValue { set; }
    }

    public MyInnerClass InnerClass = new MyInnerClass();
    private readonly IInnerClass myInnerClass;

    public MyOuterClass()
    {
        myInnerClass = InnerClass;
    }

    //A method to test access
    void test()
    {
        myInnerClass.MyValue = 123;
    }

    public class MyInnerClass : IInnerClass
    {
        //Used outside OuterClass when OuterClass.InnerClass 
        //properties are called
        public int MyValue { get; private set; }
        // Implement the interface which can have other
        // access specifiers! get is not part of the
        // interface and is provided by MyInnerClass
        // This setter can only be called in MyOuterClass
        int IInnerClass.MyValue { set => this.MyValue = value; }
    }
}

In other parts of the code the code fragment below will yield the error “Error CS0272 The property or indexer ‘MyOuterClass.MyInnerClass.MyValue’ cannot be used in this context because the set accessor is inaccessible”

MyOuterClass c = new MyOuterClass();
c.InnerClass.MyValue = 123;

In .NET 6.0 adding a MDI child only seems to work after the MDI parent is loaded. Therefore add the MDI child creation code in the Shown event handler and all functions correctly.

    private void MDIParent_Shown(object sender, EventArgs e)
    {
       MDIChild child = new MDIChild();
       child.MdiParent = this;
       child.Show();
    }

MDIForm is a standard form, note that the MDIParent form needs the IsMdiContainer property set to true;

Two simple extensions methods to make formatting with the TextWriter class more easier and IMHO easier to read.

static class extensionMethods
{  
   public static void Format(this System.IO.TextWriter writer, string format, 
   params object[] args)
   {
      writer.Write(String.Format(formatInfo, format, args));
   }

   public static void FormatLine(this System.IO.TextWriter writer, string format,
   params object[] args)
   {
      writer.WriteLine(String.Format(formatInfo, format, args));
   }
};

Add a text with a specific font and color to a RichTextBox control.

static class extensionMethods
{
  public static void AppendText(this RichTextBox textBox, string appendText, 
  System.Drawing.Color textColor = null, Font TextFont = null)
  {
      textBox.SelectionStart = textBox.TextLength;
      textBox.SelectionLength = 0;
      if (textColor != null) textBox.SelectionColor = textColor;
      if (textFont != null)  textBox.SelectionFont = textFont;
      textBox.AppendText(appendText);
      textBox.SelectionColor = textBox.ForeColor;
   }
};

Get an existing item from a dictionary or create a new value with a default value, using an extension method.

 static class extensionMethods
 {

     public static V TryGetValueOrCreate<K, V>(this Dictionary<K, V> dictionary, K key) 
     where V : new()
    {
       V data;
       if (!dictionary.TryGetValue(key, out data))
       {
          data = new V();
          dictionary.Add(key, data);
       }
       return (data);
    }
 }

The method above can be used using the code below:

public class Item
{
   public int test;
};

Dictionary<int,Item> dict = new Dictionary<int,Item>();
Item item = dict.TryGetValueOrCreate(3);
item.test= 123;