Отсортировать массив между первым и последним отрицательным элементом по возрастанию

Столкнулась с проблемой того,что непрвильно определяются отрицательные числа. Выводится не только первый и последние отрицательные, но и другие,которые есть в массиве.

Также массив не сортируется и выводится на экран таким же,какой был вначале. Задание было таким:

1. Найти сумму положительных элементов с нечетными индексами.

2. Сортировать элементы, расположенные между первым и последним отрицательным элементом по возрастанию значений элементов.

   using System;
   using static System.Random;
   using  static System.Math;
   namespace lab1
   {
   class Program
   {
   public static void Main(string[] args)
   {
       int someLength;
       int someLength1;
       Console.WriteLine("Введите количество строк массива:");
       someLength = int.Parse(Console.ReadLine());
       Console.WriteLine("Введите количество столбцов массива:");
       someLength1 = int.Parse(Console.ReadLine());
       double[,] array = new double[someLength, someLength1];
       Random x = new Random();
       for (int i = 0; i < someLength; i++)
       {
           for (int j = 0; j < someLength1; j++)
           {
               array[i, j] = (Convert.ToDouble(x.Next(-100, 100) / 10.0));
           }
       }
       Console.WriteLine("Исходная матрица:");
       for (int i = 0; i < array.GetLength(0); i++)
       {
           for (int j = 0; j < array.GetLength(1); j++)
               Console.Write("{0}\t", (array[i, j]));
           Console.WriteLine();
       }
       SumPositiveElem(ref array);
       OrderElem(ref array);
       Console.ReadKey();
   }
   static public double SumPositiveElem(ref double[,] array)
   {
       double sum = 0;
       for (int i = 0; i < array.GetLength(0); i++)
       {
           for (int j = 0; j < array.GetLength(1); j++)
           {
               if ((i % 2 != 0 && j % 2 != 0) && array[i, j] > 0)
               {
                   sum += array[i, j];
               }
           }
       }
       Console.WriteLine("Сумма положительных элементов с ннечетными индексами =" +sum);
       return sum;
   }
   static public double OrderElem(ref double[,] array)
   {
                   int first = 0;
                   int second = 0;
                   int k = 0;
                   int l = 0;
                   int m = 0;
                   int n = 0;
                   double temp;
                   if (first == 0)
                   {
                       for (int i = 0; i < array.GetLength(0); i++)
                       {
                           for (int j = 0; j < array.GetLength(1); j++)
                           {
                               if (array[i, j] < 0)
                               {
                                   Console.WriteLine(array[i, j]);
                                   first = 1;
                                   k = i;
                                   l = j;
                                   break;
                               }
                           }
                       }
                   }
                   if (first == 1)
                   {
                       for (int i = array.GetLength(0) - 1; i >=0 ; i--)
                       {
                           for (int j = array.GetLength(1) - 1; j>= 0; j--)
                           {
                               if ((array[i, j] < 0)&& i!=k&&j!=l&& second==0)
                               {
                                   Console.WriteLine(array[i, j]);
                                   second = 1;
                                   m = i;
                                   n = j;
                                   break;
                               }
                           }
                       }
                   }
                   for (int a = k; a < m; a++)
                           {
                               for (int b = l; b < n; b++)
                               {
                                    if( array[a,b]< array[a,b+1] ) {
                                       double tmp = array[a,b];
                                       array[a,b] = array[a,b+1];
                                       array[a,b+1] = tmp;
                                   }
                           }
                       }
                           for (int i= 0; i < array.GetLength(0); i++)
                           {
                               for (int j = 0; j < array.GetLength(1); j++)
                                   Console.Write("{0}\t", (array[i, j]));
                               Console.WriteLine();
                           }
                           if (second == 0) Console.WriteLine("Только 1 отрицательный элемент");
                           if (first==0&& second==0) Console.WriteLine("Нет отрицательных элементов");
                   return 0;
               }
   }
   

   }

Вот пример одного из выводов консоли:

Введите количество строк массива:
 3
Введите количество столбцов массива:
 3
   Исходная матрица:
   -3,5    9,9     6
    2,2     1,5     3
    2,4     -6,5    8,1
       Сумма положительных элементов с нечетными индексами =1,5
 -3,5
 -6,5
 -3,5
  -3,5    9,9     6
  2,2     1,5     3
  2,4     -6,5    8,1