ООП: Создать метод, который выдает среднее арифметическое чисел заданных значений

    private static double Average( int[] arr )
    {
        int sum = 0;
        for ( int i = 0; i < arr.Length; i++ ) sum += arr[ i ];
 
        double average = sum/arr.Length;
        for ( int i = 0; i < arr.Length; i++ )
            if ( arr[ i ] > average )
                arr[ i ] = 0;
            else if ( arr[ i ] < average )
                arr[ i ] = 1;
        return average;
    }

 class Program
    {
        static void Main(string[] args)
        {
            double[] massiv = { 1, 2, 3, 4, 5, 6 };
           Srednestat aver = new Srednestat();
           aver.Srstat(massiv);
           Console.Read();
        }
    }
    class Srednestat
    {
        public void Srstat(double[] a)
        {
            
            Console.WriteLine(average(a).ToString());
            Console.ReadKey();
        }
        static double average(double[] a)
        {
 
            double sum = 0;
            for (int i = 0; i < a.Length; i++)
                sum += a[i];
            return sum / a.Length;
        }
    }

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
 
namespace Codeforces.Div2._181
{
    internal class Prog
    {
        private static void Main()
        {
            using(var app = new Application())
                app.Run();
            Console.ReadKey();
        }
    }
 
    class Application : IDisposable
    {
        private readonly InputOutput<int> _inputOutput;
 
        public Application()
        {
            _inputOutput = InOutFactory.Create();
        }
 
        public Application(string fileIn, string fileOut)
        {
            _inputOutput = InOutFactory.Create(fileIn, fileOut);
        }
 
        public void Run()
        {
            var items = _inputOutput.ReadData();
            var avg = ArithmeticHelper.Avg(items);
            ArrayHelper.Replace(items, avg);
            _inputOutput.WriteLine(avg);
            _inputOutput.WriteData(items);
        }
 
        public void Dispose()
        {
            _inputOutput.Dispose();
        }
    }
 
    static class InOutFactory
    {
        public static InputOutput<int> Create(string fileIn, string fileOut)
        {
            return new FileInputOutput(fileIn, fileOut);
        }
 
        public static InputOutput<int> Create()
        {
            return new ConsoleInputOutput();
        }
    }
 
    abstract class InputOutput<T> : IDisposable
    {
        protected  readonly TextReader _reader;
        protected  readonly TextWriter _writer;
 
        protected InputOutput(TextReader reader, TextWriter writer)
        {
            _reader = reader;
            _writer = writer;
        }
 
        public T[] ReadData()
        {
           return ToArray(_reader.ReadLine());
        }
 
        public void WriteData(IEnumerable<T> data)
        {
            _writer.WriteLine(ToString(data));
        }
 
        public void WriteLine(double avg)
        {
            _writer.WriteLine(avg);
        }
 
        protected abstract T[] ToArray(string line);
        protected abstract string ToString(IEnumerable<T> data);
        public void Dispose()
        {
            Dispose(true);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            
        }
    }
 
    class InputOutput4Int32 : InputOutput<int>
    {
        public InputOutput4Int32(TextReader reader, TextWriter writer) : base(reader, writer)
        {
        }
 
        protected override int[] ToArray(string line)
        {
            return line.Split().Select(int.Parse).ToArray();
        }
 
        protected override string ToString(IEnumerable<int> data)
        {
            return string.Join(" ", data);
        }
    }
 
    class FileInputOutput : InputOutput4Int32
    {
        public FileInputOutput(string fileNameIn, string fileNameOut) : base(new StreamReader(fileNameIn), new StreamWriter(fileNameOut))
        {
            
        }
        protected override void Dispose(bool disposing)
        {
            _reader.Dispose();
            _writer.Dispose();
        }
    }
 
    class ConsoleInputOutput : InputOutput4Int32
    {
        public ConsoleInputOutput() : base(Console.In, Console.Out)
        {
        }
    }
 
    static class ArithmeticHelper
    {
        public static double Avg(int[] items)
        {
            return items.Average();
        } 
    }
 
    static class ArrayHelper
    {
        public static void Replace(int[] items, double avg)
        {
            for (int i = 0; i < items.Length; ++i)
                if(avg != items[i])
                    items[i] = avg < items[i] ? 0 : 1;
        }
    }
}