AOC 2021 Day20 iterative c#

using System;
using System.Numerics;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;

namespace AOC2021
{
    public class Day20 : ISolvable
    {

        public Day20(string[] lines)
        {
            Algo = lines[0];
            var length = lines[2].Length;
            Grid = new int[length, length];


            for (int i = 0; i < length; i++)
            {
                for (int j = 0; j < length; j++)
                {
                    Grid[i, j] = lines[i + 2][j] == '#' ? 1 : 0;
                }
            }
        }

        private int[,] Solve(int n)
        {
            var grid = Grid;
            while (n > 0)
            {
                Console.WriteLine(new string('-', 80));
                Console.WriteLine("Initial State:");
                Utilities.PrintGridNumbers(grid);
                grid = Add_Border(grid, 2, n % 2 == 0);
                Console.WriteLine("After padding:");
                Utilities.PrintGridNumbers(grid);
                var next_grid = (int[,])grid.Clone();
                for (int i = 1; i < grid.GetLength(0) - 1; i++)
                {
                    for (int j = 1; j < grid.GetLength(1) - 1; j++)
                    {
                        var binary = grid[i - 1, j - 1].ToString() + grid[i - 1, j].ToString() + grid[i - 1, j + 1].ToString() +
                                     grid[i, j - 1].ToString() + grid[i, j].ToString() + grid[i, j + 1].ToString() +
                                     grid[i + 1, j - 1].ToString() + grid[i + 1, j].ToString() + grid[i + 1, j + 1].ToString();
                        next_grid[i, j] = Algo[Convert.ToInt32(binary, 2)] == '#' ? 1 : 0;
                    }
                }
                grid = next_grid;
                Console.WriteLine("After Algo:");
                Utilities.PrintGridNumbers(grid);
                n--;
            }
            return grid;
        }

        /**
         *
         * 12
         * 34
         *
         * -> 1
         *
         * 0000
         * 0120
         * 0340
         * 0000
         * */

        private int[,] Add_Border(int[,] grid, int border_size, bool is_odd)
        {
            var length = grid.GetLength(0);
            var new_grid = new int[length + 2 * border_size, length + 2 * border_size];

            for (int i = 0; i < length + 2 * border_size; i++)
            {
                for (int j = 0; j < length + 2 * border_size; j++)
                {
                    if (i < border_size || j < border_size || i >= border_size + length || j >= border_size + length)
                        new_grid[i, j] = is_odd && Algo[0] == '#' ? 1 : 0;
                    else
                        new_grid[i, j] = grid[i - border_size, j - border_size];
                }
            }

            length += border_size * 2;

            return new_grid;
        }

        public string Algo { get; }
        public int[,] Grid { get; }

        public object SolvePart1()
        {
            var grid = Solve(2);
            return Enumerable.Range(0, grid.GetLength(0)).Select(i => Enumerable.Range(0, grid.GetLength(1)).Select(j => grid[i, j]).Sum()).Sum();
        }

        public object SolvePart2()
        {
            throw new NotImplementedException();
        }

        static void Main(string[] args)
        {
            var lines = File.ReadAllLines("input.txt");
            var sw = new Stopwatch();
            sw.Start();
            var solver = new Day20(lines);
            sw.Stop();
            var precalc_time = sw.Elapsed;
            Console.WriteLine("Precalculations took: {0}", precalc_time);

            sw.Restart();
            var part1_solution = solver.SolvePart1();
            sw.Stop();
            var part1_time = sw.Elapsed;
            Console.WriteLine("{0} Part 1 Solution: < {1} > Took: {2}", solver.GetType().Name, part1_solution, part1_time);

            sw.Restart();
            var part2_solution = solver.SolvePart2();
            sw.Stop();
            var part2_time = sw.Elapsed;
            Console.WriteLine("{0} Part 2 Solution: < {1} > Took: {2}", solver.GetType().Name, part2_solution, part2_time);
            Console.WriteLine("Complete runtime: {0}", precalc_time + part2_time + part2_time);
        }
    }
}