Método Array.GetValue() en C# con ejemplos | Juego – 4

El método Array.GetValue() en C# se usa para obtener el valor del elemento especificado en el Array actual . Hay un total de 8 métodos en la lista de sobrecarga de este método, que son los siguientes:

• Array.ObtenerValor(Int32, Int32)
• Array.ObtenerValor(Int64, Int64)
• Array.ObtenerValor(Int32)
• Array.ObtenerValor(Int64)
• Array.ObtenerValor(Int32, Int32, Int32)
• Array.ObtenerValor(Int64, Int64, Int64)
• Array.ObtenerValor(Int32[])
• Array.ObtenerValor(Int64[])

En este artículo explicamos el método Array.GetValue(Int32[]) y Array.GetValue(Int64[]) .

El método Array.GetValue(Int32[]) se usa para obtener el valor en la posición especificada en el Array multidimensional. Los índices se pasan a este método mediante una array 1D, es decir, la array 1D que se pasa contiene el índice especificado como elemento de array de la array 1D, y el elemento que se buscará está en ese índice que está en la array 1D . Los índices se especifican como enteros de 32 bits. 

Sintaxis: 
 

public object GetValue (int[] index);

Aquí, «índice» es una array 1D de enteros de 32 bits que representan el índice que especifica la posición del elemento que se buscará. buscado

Devoluciones: este método devuelve el elemento en el índice especificado definido por la array 1D pasada al método GetValue . El valor es un valor entero de 32 bits.

Excepciones:

• ArgumentException: si la cantidad de dimensiones en la array actual no es igual a la cantidad de elementos en la array de índice que se pasa al método GetValue .
• IndexOutOfRangeException: si los elementos en la array de índices definen un rango que está fuera del rango de índices válidos para la dimensión correspondiente de la array actual.
• ArgumentNullException: si la array de índice es nula, se lanza.

El método Array.GetValue(Int64[]) se usa para obtener el valor en la posición especificada en el Array multidimensional. Los índices se pasan a este método mediante una array 1D, es decir, la array 1D que se pasa contiene el índice especificado como elemento de array de la array 1D, y el elemento que se buscará está en ese índice que está en la array 1D . Los índices se especifican como enteros de 64 bits. 

Sintaxis: 

public object GetValue (long[] index);

Aquí, «índice []» es una array 1D de enteros de 64 bits que representan el índice que especifica la posición del elemento que se buscará.

Devoluciones: este método devuelve el elemento en el índice especificado definido por la array 1D pasada al método GetValue . El valor es un valor entero de 32 bits.

Excepciones:

• ArgumentException: si la cantidad de dimensiones en la array actual no es igual a la cantidad de elementos en la array de índice que se pasa al método GetValue .
• ArgumentOutOfRangeException: si los elementos en la array de índices definen un rango que está fuera del rango de índices válidos para la dimensión correspondiente de la array actual.
• ArgumentNullException: si la array de índice es nula, se lanza.

Ejemplo 1:
 

// C# program to demonstrate the
// Array.GetValue(Int32[]) and
// Array.GetValue(Int64[]) method
using System;
public class GFG {
  
public static void Main() {
    
    // declare a character
    // array of size 1x2x2x3
    // it has 2 3D array
    // which have 2 row and 3 column each
    char[, , , ] arr = new char[1, 2, 2, 3]{
        {
  
            {// array 1
             {'A', 'B', 'C'},
             {'D', 'E', 'F'}
  
            },
            {// array 2
             {'G', 'H', 'I'},
             {'J', 'K', 'L'}}
  
        }
        /*Array look like
   |----------------------------------|
   | -------------------------------- |
   |  |A|          |B|           |C|  |
   |  |D|          |E|           |F|  |
   | -------------------------------- |
   | -------------------------------- |
   |  |G|          |H|           |I|  |
   |  |J|          |K|           |L|  |
   | -------------------------------- |
   |__________________________________|
   */
    };
  
    // initialize a integer array
    // contains the index of the element
    // index of 'L'
    int[] indx = new int[4]{0, 1, 1, 2};
  
    // "indx" array is passing
    // to GetValue(Int32[]) method
    Console.WriteLine("Element at index [0, 1, 1, 2] is : {0}",
                                           arr.GetValue(indx));
  }
}

Element at index [0, 1, 1, 2] is : L

Ejemplo 2:

// C# program to demonstrate the
// Array.GetValue(Int32[]) and
// Array.GetValue(Int64[]) method
using System;
  
class GFG {
  
public static void Main() {
    
    // declare a character
    // array of size 1x2x2x3
    // it has 2 3D array
    // which have 2 row and
    // 3 column each
    string[, , , ] arr = new string[1, 2, 2, 3];
    
    /*Array look like
|------------------------------------|
| ---------------------------------- |
|  |C++|          |Java|       |C#|  |
|  |Perl|          |python|    |PHP| |
| ---------------------------------- |
| ---------------------------------- |
|  |Ruby|        |F#|       |Julia|  |
|  |SQL|        |Kotlin|       |GO|  |
| ---------------------------------- |
|____________________________________|
*/
  
    arr.SetValue("C++", 0, 0, 0, 0);
    arr.SetValue("Java", 0, 0, 0, 1);
    arr.SetValue("C#", 0, 0, 0, 2);
    arr.SetValue("Perl", 0, 0, 1, 0);
    arr.SetValue("Python", 0, 0, 1, 1);
    arr.SetValue("PHP", 0, 0, 1, 2);
    arr.SetValue("Ruby", 0, 1, 0, 1);
    arr.SetValue("F#", 0, 1, 0, 1);
    arr.SetValue("Julia", 0, 1, 0, 2);
    arr.SetValue("SQL", 0, 1, 1, 0);
    arr.SetValue("kotlin", 0, 1, 1, 1);
    arr.SetValue("GO", 0, 1, 1, 2);
  
    // initialize a integer array
    // contains the index of the element
    // index of 'C#'
    int[] indx = new int[4]{0, 1, 1, 2};
  
    // "indx" array is passing
    // to GetValue(Int32[]) method
    Console.WriteLine("Element at index [0, 1, 1, 2] is : {0}",
                                           arr.GetValue(indx));
  }
}

Element at index [0, 1, 1, 2] is : GO

Nota: Para el compilador en línea, no es posible usar enteros de 32 o 64 bits. Use el compilador fuera de línea para enteros de 32 o 64 bits.