public partial class Solution {      
    
    /// <summary>
    /// MaxAreaOfIsland
    /// </summary>
    /// <param name="grid">grid</param>
    /// <returns>maximum area of an island</returns>
    public int MaxAreaOfIsland(int[][] grid) {
        var maxAreaOfIsland = 0;
        for(var i=0;i<grid.Length;i++)
        {
            for(var j=0;j<grid[0].Length;j++)
            {
                if(IsIsland(grid[i][j]))
                {
                    var islandAreas = new List<(int,int)>();
                    TraverseIsland(islandAreas,grid,i,j);
                    maxAreaOfIsland = Math.Max(islandAreas.Count,maxAreaOfIsland);
                }
            }
        }
        return maxAreaOfIsland;
    }
}

///
/// private method & variant
///
public partial class Solution {      
    
    private enum AreaEnum 
    {
      None = 0,
      Island = 1,
      HasBeenTraverse = 2,
    };

    /// <summary>
    /// Check the location that is island
    /// </summary>
    /// <param name="gridValue">value of grid</param>
    /// <returns>bool</returns>
    private bool IsIsland(int gridValue)
        => gridValue == (int)AreaEnum.Island;

    /// <summary>
    /// Mark the traversal to avoid infinite loops
    /// </summary>
    /// <param name="grid">grid</param>
    /// <param name="i">i of grid</param>
    /// <param name="j">j of grid</param>
    private void MarkTraversal(int[][] grid,int i,int j)
        => grid[i][j] = (int)AreaEnum.HasBeenTraverse;
    
    /// <summary>
    /// Traverse Island
    /// Traverse the grid 4-directionally
    /// </summary>
    /// <param name="islandAreas">areas of the island</param>
    /// <param name="grid">grid object</param>
    /// <param name="i">i of grid</param>
    /// <param name="j">j of grid</param>
    private void TraverseIsland (
        List<(int,int)> islandAreas, 
        int[][] grid,
        int i, 
        int j)
    {
        islandAreas.Add((i,j));
        MarkTraversal(grid,i,j);
        
        // top
        if(i-1 >= 0 && IsIsland(grid[i-1][j])) 
            TraverseIsland(islandAreas,grid,i-1,j);
        // bottom
        if(i+1 < grid.Length && IsIsland(grid[i+1][j]))
            TraverseIsland(islandAreas,grid,i+1,j);
        // left
        if(j-1 >= 0 && IsIsland(grid[i][j-1])) 
            TraverseIsland(islandAreas,grid,i,j-1);
        // right
        if(j+1 < grid[0].Length && IsIsland(grid[i][j+1]))
            TraverseIsland(islandAreas,grid,i,j+1);
    }
}

using System;
using System.Text.Json;

namespace NonReferenceObj
{
    internal class Program
    {
        /// <summary>
        /// Order
        /// </summary>
        public class Order
        {
            public int Seq { get; set; }
            public string No { get; set; }
            public decimal Amount { get; set; }
        }

        /// <summary>
        /// Util
        /// </summary>
        public class Util
        {
            /// <summary>
            /// Deep Clone
            /// Copy a non-reference object
            /// </summary>
            /// <typeparam name="T">T</typeparam>
            /// <param name="obj">obj</param>
            /// <returns></returns>
            public static T DeepClone<T>(T obj)
            => JsonSerializer.Deserialize<T>(JsonSerializer.Serialize(obj));
        }

        static void Main()
        {
            var order = new Order
            {
                Seq = 1,
                No = "20220608",
                Amount = 100,
            };

            var copy = Util.DeepClone(order);

            // Check the reference of object 
            Console.WriteLine($"Check the reference of object: {object.ReferenceEquals(order, copy)}");
            // Check the equal of value  
            Console.WriteLine($"Check the equal of value: {order.No == copy.No && order.Seq == copy.Seq && order.Amount == copy.Amount}");
        }
    }
}

using System;
using System.Collections.Generic;

namespace refactor01
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var numbers = new List<string>();
            for(var i = 0; i < 10; i++)
            {
                numbers.Add(i.ToString());
            }
            foreach (var item in numbers)
            {
                Console.Write(item);
            }
        }
    }
}

using System;
using System.Collections.Generic;

namespace refactor01
{
    internal class Program
    {
        static void Main()
        {
            var numbers = new List<string>();
            initNumbers(numbers);
            printNumbers(numbers);
        }

        /// <summary>
        /// init the numbers
        /// </summary>
        /// <param name="numbers">list of numbers</param>
        public static void initNumbers(List<string> numbers)
        {
            for (var i = 0; i < 10; i++)
            {
                numbers.Add(i.ToString());
            }
        }

        /// <summary>
        /// print the numbers
        /// </summary>
        /// <param name="numbers">list of numbers</param>
        public static void printNumbers(List<string> numbers)
        {
            foreach (var item in numbers)
            {
                Console.Write(item);
            }
        }
    }
}

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

namespace LargeData
{
    public class OrderModel
    {
        public string OrderNumber { get; set; }
    }
    public class Program
    {
        private static readonly int _dataCount = 20000000;
        public static void Main()
        {
            var list = new List<OrderModel>();
            for (var i = 0; i < _dataCount; i++)
            {
                list.Add(new OrderModel
                {
                    OrderNumber = $"{i + 1}"
                });
            }

            Stopwatch sw = new Stopwatch();
            sw.Reset();
            sw.Start();

            var result = list.ToList();
            var targetOrderNumber = "20000000";
            var targetOrder = list
                .Where(x => x.OrderNumber == targetOrderNumber)
                .FirstOrDefault();

            Console.WriteLine($"TargetOrder:{targetOrder.OrderNumber}");

            sw.Stop();
            string second = (sw.Elapsed.TotalMilliseconds / 1000).ToString();
            Console.WriteLine($"Run:{second}");
        }
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text.Json;

namespace ListGroupBy
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var numbers = new List<string>
            {
                "00001","00002","00003","00004","00005"
            };

            var numberGroup = numbers
                .Select((number, index) => new { number, index })
                .GroupBy(g => g.index / 2, i => i.number)
                .ToList();

            //It will iterate through each groups
            foreach (var group in numberGroup)
            {
                Console.WriteLine($"{group.Key} ,  count: {group.Count()}");
                //Iterate through each number of a group
                foreach (var number in group)
                    Console.WriteLine($"  number : {number}");
            }
        }
    }
}