C#-Code

using System;
using static System.Console;
using static System.ConsoleKey;

//http://www.matheboard.de/archive/529571/thread.html
//http://www.matheboard.de/archive/25782/thread.html

namespace mittlerer_abstand_zweier_kreispunkte
{
    static class Program
    {
        static string NL = Environment.NewLine, Version = "version 18.12.2017" + NL;

        static void Main()
        {
            Version.MessageLine();
            bool bo_loop = true;
            while (bo_loop)
            {
                int max_trails = (int)1e+6;
                double r1 = 0, r2 = 0;

                bool bo_input_okay = false;
                while (!bo_input_okay)
                {
                    "give me r1: ".Message();
                    string string_input = ReadLine();
                    bo_input_okay = double.TryParse(string_input, out r1) && (r1 >= 0.0);
                }
                bo_input_okay = false;
                while (!bo_input_okay)
                {
                    "give me r2: ".Message();
                    string string_input = ReadLine();
                    bo_input_okay = double.TryParse(string_input, out r2) && (r2 >= 0.0);
                }

                string[] info = { "line     ", "quad     ", "rect     ", "circle   ", "ellipse  " };

                double[][] radii = new double[][]  //  die formenmittelpunkte liegen bei (0.0, 0.0)
                {
                    new double[]{r1, 0.0},                    new double[]{r2, 0.0},    //line

                    new double[]{r1,  r1},                    new double[]{r2,  r2},    //quadrat
                    new double[]{r1,  r2},                    new double[]{r2,  r1},    //recheck

                    new double[]{r1,  r1},                    new double[]{r2,  r2},    //kreis
                    new double[]{r1,  r2},                    new double[]{r2,  r1}     //ellipse
                };

                Delegate [][] deligierte = new Delegate[][] //  regarding radii
                {
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Quad_Rect_Line, (IsIn_Area)MyDistance_Delegates.IsIn_Quad_Rect_Line },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Quad_Rect_Line, (IsIn_Area)MyDistance_Delegates.IsIn_Quad_Rect_Line },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Quad_Rect_Line, (IsIn_Area)MyDistance_Delegates.IsIn_Quad_Rect_Line },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Quad_Rect_Line, (IsIn_Area)MyDistance_Delegates.IsIn_Quad_Rect_Line },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Quad_Rect_Line, (IsIn_Area)MyDistance_Delegates.IsIn_Quad_Rect_Line },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Quad_Rect_Line, (IsIn_Area)MyDistance_Delegates.IsIn_Quad_Rect_Line },

                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Circle_Ellipse, (IsIn_Area)MyDistance_Delegates.IsIn_Circle_Ellipse },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Circle_Ellipse, (IsIn_Area)MyDistance_Delegates.IsIn_Circle_Ellipse },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Circle_Ellipse, (IsIn_Area)MyDistance_Delegates.IsIn_Circle_Ellipse },
                    new Delegate[] { (Circumference)MyDistance_Delegates.Circumference_Circle_Ellipse, (IsIn_Area)MyDistance_Delegates.IsIn_Circle_Ellipse }
                };

                (NL + "Results from Class_Mean_Distances in a Loop").MessageLine();
                for (var i = 0; i < radii.Length; i++)
                {
                    Class_Mean_Distances
                        cmd = new Class_Mean_Distances(radii[i][0], radii[i][1], max_trails, (Circumference)deligierte[i][0], (IsIn_Area)deligierte[i][1]);
                    $"{info[i / 2]}max_trails: {max_trails.ToString("n0")}    r1: {radii[i][0],10}   result = {(100.0 * cmd.result).ToString("0.0000"),5} %    r2: {radii[i][1],10}".MessageLine();
                }

                (NL + "test circumference calculation for ellipse").MessageLine();
                Class_Mean_Distances
                    cmd_exact = new Class_Mean_Distances(r1, r2, max_trails, MyDistance_Delegates.Circumference_Ellipse_exact, MyDistance_Delegates.IsIn_Circle_Ellipse);
                $"exact:   max_trails: {max_trails.ToString("n0")}    r1: {r1,10}   result = {(100.0 * cmd_exact.result).ToString("0.0000"),5} %    r2: {r2,10}   U_exact: {cmd_exact.U.ToString()}".MessageLine();
                    cmd_exact = new Class_Mean_Distances(r1, r2, max_trails, MyDistance_Delegates.Circumference_Circle_Ellipse, MyDistance_Delegates.IsIn_Circle_Ellipse);
                $"approx:  max_trails: {max_trails.ToString("n0")}    r1: {r1,10}   result = {(100.0 * cmd_exact.result).ToString("0.0000"),5} %    r2: {r2,10}   U      : {cmd_exact.U.ToString()}".MessageLine();

                ConsoleKeyInfo ki = "press any key (exit => ESC)".ReadKey(bo_NL: true);
                bo_loop = !(ki.Key == Escape);
            }
            "ready, press a key".ReadKey(true);
        }

        #region expansions

        public static void Message(this string s) => Write(s);

        public static void MessageLine(this string s) => WriteLine(s);

        public static ConsoleKeyInfo ReadKey(this string s, bool bo_NL = false)
        {
            if (bo_NL) s.MessageLine(); else s.Message();
            return System.Console.ReadKey(true);
        }
        #endregion
    }

    // define delegates

    public delegate double Circumference(double r1, double r2);
    public delegate bool IsIn_Area(double r1, double r2, double x, double y);    

    public static class MyDistance_Delegates // create methods for the delegates
    {
        public static bool IsIn_Quad_Rect_Line(double r1, double r2, double x, double y) => true;   //quad: r2 = r1; line: r2 = 0

        public static double Circumference_Quad_Rect_Line(double r1, double r2) => 4 * (r1 + r2);   //quad: r2 = r1; line: r2 = 0

        public static bool IsIn_Circle_Ellipse(double r1, double r2, double x, double y)            //circle: r2 = r1
            => ((x - r1) * (x - r1) * r2 * r2 + (y - r2) * (y - r2) * r1 * r1 <= r1 * r1 * r2 * r2);

        public static double Circumference_Circle_Ellipse(double r1, double r2)                     //circle: r2 = r1
        {
            double lambda = (r1 - r2) / (r1 + r2);  //approximation from Ramanujan; for circles (lambda = 0) exact
            return Math.PI * (r1 + r2) * (1.0 + 3 * lambda * lambda / (10.0 + Math.Sqrt(4.0 - 3.0 * lambda * lambda)));
        }

        public static double Circumference_Ellipse_exact(double r1, double r2)                     //circle: r2 = r1
        //see https://de.wikipedia.org/wiki/Ellipse
        {
            double lambda = (r1 - r2) / (r1 + r2), lambda_quadrat = lambda * lambda;
            double error = 1.0E-16; //1.0E-38;

            double sum = 1.0, sum_old = 0.0, sum_n = 1.0;
            double no = 1, nu = 1;
            int n = 0;
            while((sum - sum_old) > error)
            {
                sum_old = sum;
                no = (2 * n - 1);
                nu = (2 * n + 2);
                double q = (double)no / (double)nu;
                sum_n *= lambda_quadrat * q * q;
                sum += sum_n;
                n++;
            }
$"n from Circumference_Ellipse_exact: {n.ToString("n0")}".MessageLine();
            return sum * Math.PI * (r1 + r2);
        }
    }

    public class Class_Mean_Distances   //  with use of delegates
    {
        private double r1, r2;
        private int max_loops;

        private Circumference circumstance;
        private IsIn_Area bo_isinarea;

        private Random rand = new Random();

        public double U, result;

        public Class_Mean_Distances(double r1, double r2, int max_loops, Circumference circumstance, IsIn_Area bo_isinarea)
        {
            this.r1 = r1;
            this.r2 = r2;
            this.max_loops = max_loops;
            this.circumstance = circumstance;
            this.bo_isinarea = bo_isinarea;

            this.run();
        }

        private void run()
        {
            int counter = 0;
            double distance = 0.0;
            while (counter < max_loops)
            {
                double[][] xy = new double[2][];
                for(var i = 0; i < xy.Length; i++)
                {
                    bool bo = false;
                    while (!bo)
                    {
                        double x = rand.NextDouble() * 2 * r1;
                        double y = rand.NextDouble() * 2 * r2;
                        xy[i] = new double[] { x, y };
                        bo = bo_isinarea(r1, r2, xy[i][0], xy[i][1]);
                    }
                }
                double act_distance = Math.Sqrt((xy[0][0] - xy[1][0]) * (xy[0][0] - xy[1][0]) + 
                                                (xy[0][1] - xy[1][1]) * (xy[0][1] - xy[1][1]));
                distance += act_distance;
                counter++;
            }
            U = circumstance(r1, r2);
            this.result = (distance / max_loops) / U;
        }
    }
}