SoloCodigo

Hola soy nuevo en esta comunidad, y quisiera saber si me pueden ayudar con este problema de una tarea en la que ocupo un ejemplo de un arreglo, el cual desde el main se pueda mandar vacio y en una clase se pueda llenar, ya lleno el arreglo que se regrese al main. Desde ahí mandarlo a cuantas clases sea necesario y poder alterar sus datos, como si fuese una base de datos

Gracias por contestar

Aquí les mando otra duda, en este caso el programa a continuación  en donde se crean las clase y el arreglo, todo funciona bien, pero en la clase modificar a la hora de querer cambiar el valor del arreglo marca un error.

************************ este es el programa principal**************************

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

namespace Arreglos
{
    class Program
    {
        // a esto no le haga caso
       // public int[,] arreglox = new int[2, 2];

        // estructura pricipal del programa
        static void Main(string[] args)
        {
            int contador1 = 0; // no hacer caso a esto
            int contador2 = 0; //  no hacer caso a esto
            int linea = 0;     // variable que contendrá el numero de línea para el arreglo.
            int columna = 0;   // variable que contendrá el número de columna para el arreglo.

           
            // se declaran las clases.

            Clase_Arreglos Miarreglo = new Clase_Arreglos(); // en esta clase se rellena el arreglo.
            Clase_modificar Miarreglo2 = new Clase_modificar(); // en esta clase se modifica un elemento del arreglo.
                                                                // quiém sabe por que no lo hace.

            // se declara el arreglo.
            int[,] arreglox  = new int [2,2];


            // se inicializan las variables.
            linea = 0;
            columna = 0;


            // aquí se checa que el arreglo esté vacio, por que no tiene ningún valor.
            for (linea = 0; linea < 2; linea++)
            {
                for (columna = 0; columna < 2; columna++)
                {
                    Console.WriteLine("El arrglo desde el main tiene los siguientes valores " + arreglox[linea, columna]);
                }
            }


            // se manda el arreglo a esta clase para que se llenado.
            Clase_Arreglos.Miarreglo(ref linea, ref columna, ref arreglox);

            linea = 0;
            columna = 0;

            // aquí se verifica que el arreglo esté llenado. Se despliegan sus valores.
            for (linea = 0; linea < 2; linea++)
            {
                for (columna = 0; columna < 2; columna++)
                {
                    Console.WriteLine("El arrglo desde el main despues de ser llenado tiene los siguientes valores " + arreglox[linea, columna]);
                }
            }

            // aquí se manda el arreglo para ser modificado un sólo elemento, el que le indiquemos.
            // aquí no funciona lo que se quiere hacer.
            Clase_modificar.Miarreglo2(ref linea, ref columna, ref arreglox);

            linea = 0;
            columna = 0;

            // aquí se despliega el arreglo modificado, o sea sus valores.
            for (linea = 0; linea < 2; linea++)
            {
                for (columna = 0; columna < 2; columna++)
                {
                    Console.WriteLine("El arrglo desde el main despues de ser modificado tiene los siguientes valores " + arreglox[linea, columna]);
                }
            }
            Console.Read();

        }
    }
}

******************************************** Clase donde se llena el arreglo*******************************************

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

namespace Arreglos
{
    class Clase_Arreglos
    {
        // el constructor
        public Clase_Arreglos (){}
       
        public static int Miarreglo(ref int lineaY, ref int columnaY, ref int[,] arregloy)
        {
            // se llena el arreglo con unos valores aleatorios
            for (lineaY = 0; lineaY < 2; lineaY++)
            {
                for (columnaY = 0; columnaY < 2; columnaY++)
                {
                    arregloy[lineaY, columnaY] = lineaY +columnaY;
                }
            }
            return lineaY; // sólo se regresa algo para que no ponga error, pero no se ocupa.
        }            
    }
}

***************************************************Clase donde se modifica un elemento del arreglo y donde hay problemas***********************************************

class Clase_modificar
    {
        public static int Miarreglo2(ref int lineaA, ref int columnaB, ref int[,] arregloXY)
        {
            // se declaran las variables locales.
            int nuevo_elemento;
            int elemento;

            // se piden datos, la línea y la columna para ser más exactos.
            Console.WriteLine("Deme un numero de linea que no exceda el 2");
            lineaA = Console.Read();
            Console.WriteLine("Deme un numero de columna que no exceda el 2");
            columnaB = Console.Read();

            // se hace esto por que de todas maneras no quiso hacerlo sin esto.
            elemento=Convert.ToInt32(arregloXY[lineaA, columnaB]); //Esa linea esta amarilla y me sale Indice fueras de los limites de la matriz

            // aquí se despleiga el valor que había en esa línea y columna del arreglo.
            Console.WriteLine("El valor que se encuentra en este elemento es de: " + elemento);

            // aquí se pide el un nuevo valor el cual será asignado al arreglo.
            Console.WriteLine("Ahora deme un nuevo valor para este elemento: ");
            nuevo_elemento = Console.Read();

            // aquí se iguala el nuevo valor al elemnto del arreglo en la misma línea y columna.
            arregloXY[lineaA, columnaB] = nuevo_elemento;

            // fin del corrido.
            return lineaA; // esto se puso sólo para que no de lata el C#.
        }
    }
}

Gracias de antemano

que pasa si haces esto: elemento=Convert.ToInt32(arregloXY[lineaA-1, columnaB-1]); ????????????

Ten en cuenta que si el usuario digita que quiere cambiar la columna "2" en realidad en programación se referiria a la columna "1", ya que son dos posiciones: 0 y 1... asi que columnaA=columnaA-1;

Eso no es del todo correcto.
Lo que se pasa al metodo es una copia del puntero a estructura de datos. Si se modifica por ejemplo una posicion del array, ese cambio se ve reflejado cuando se salga del metodo, pero si se asigna a la variable otra estructura de datos, ese cambio no se ve reflejado cuando se salga del metodo ( si se ve reflejado si se usa ref).

Gracias por la aclaración, siempre es importantisimo tener la autonomia de tu código y para hacerlo nada mejor que entender bien como se comportan tus varables.