title: how can i update and modify my arrays with userinput
body: <p>so I've asked this question before but couldn't seem to get anywhere so i thought i'd ask again and maybe someone can help now that I've gotten another part of my code working. so i need to know how i can update and delete an entry. i would like to clarify that i want to do this through only user input.</p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  
  namespace PlayerSystem6
  {
      class Program
      {
          static void Main(string[] args)
          {
              //The MAXPLAYERS constant is the physical table size
              const Int32 MAXPLAYERS = 23;
  
              //Declare the player tables
              Int32[] playerNumbers = new Int32[MAXPLAYERS];
              String[] playerLastNames = new String[MAXPLAYERS];
              Int32[] playerPoints = new Int32[MAXPLAYERS];
  
              //Keep track of the actual number of players (i.e. logical table size)
              Int32 playerCount = 0;
  
              //Main Driver
              char menuItem;
              Console.WriteLine("Welcome to the player system...\n");
              menuItem = GetMenuItem();
              while (menuItem != 'X')
              {
                  ProcessMenuItem(menuItem, playerNumbers, playerLastNames, playerPoints, ref playerCount, MAXPLAYERS);
                  menuItem = GetMenuItem();
              }
              Console.WriteLine("\nThank you, goodbye");
              Console.ReadLine();
          }
  
          //Returns either a 'C', 'R', 'U', 'D', 'L', or 'X' to the caller
          static char GetMenuItem()
          {
              char menuItem;
              DisplayMenu();
              menuItem = char.ToUpper(char.Parse(Console.ReadLine()));
              while (menuItem != 'C' &amp;&amp; menuItem != 'R' //JG
                  &amp;&amp; menuItem != 'L' &amp;&amp; menuItem != 'X' &amp;&amp; menuItem != 'U')
              {
                  Console.WriteLine("\nError - Invalid menu item");
                  DisplayMenu();
                  menuItem = char.ToUpper(char.Parse(Console.ReadLine()));
              }
              return menuItem;
          }
  
          static void DisplayMenu()
          {
              Console.WriteLine("\nPlease pick an item:");
              Console.WriteLine("C - Create Player");
              Console.WriteLine("R - Retrieve Player");
              Console.WriteLine("U - Update Player");
              Console.WriteLine("D - Delete Player");
              Console.WriteLine("L - List Players");
              Console.WriteLine("X - Exit");
          }
  
          //Routes to the appropriate process routine based on the user menu choice
          static void ProcessMenuItem(Char menuItem, Int32[] playerNumbers, String[] playerLastNames,
              Int32[] playerPoints, ref Int32 playerCount, Int32 MAXPLAYERS)
          {
              switch (menuItem)
              {
                  case 'C':
                      ProcessCreate(playerNumbers, playerLastNames, playerPoints, ref playerCount, MAXPLAYERS);
                      break;
                  case 'L':
                      ProcessList(playerNumbers, playerLastNames, playerPoints, playerCount);
                      break;
                  case 'R': //JG
                      ProcessRetrieve(playerNumbers, playerLastNames, playerPoints, ref playerCount, MAXPLAYERS);
                      break;
                  case 'U':
                      ProcessUpdate(playerNumbers, playerLastNames, playerPoints, playerCount, MAXPLAYERS);
                      break;
  
              }
          }
  
          //Creates a player in the tables if the array is not already full and the name is not a duplicate
          static void ProcessCreate(Int32[] playerNumbers, String[] playerLastNames,
              Int32[] playerPoints, ref Int32 playerCount, Int32 MAXPLAYERS)
          {
              Int32 number, points;
              String lastName;
              if (playerCount &lt; MAXPLAYERS)
              {
                  number = GetPositiveInteger("\nCreate Player: please enter the player's number");
                  if (GetPlayerIndex(number, playerNumbers, playerCount) == -1)
                  {
                      lastName = GetString("\nCreate Player: please enter the player's last name");
                      points = GetPositiveInteger("\nCreate Player: please enter the player's points");
                      InsertPlayer(number, lastName, points, playerNumbers, playerLastNames, playerPoints, ref playerCount);
                      Console.WriteLine("\nCreate Player: Number - {0}, Name - {1}, Points - {2}, created successfully", number, lastName, points);
                      Console.WriteLine();
                  }
                  else
                      Console.WriteLine("\nCreate Player: the player number already exists");
              }
              else
                  Console.WriteLine("\nCreate Player: the player roster is already full");
  
          }
  
          //Inserts the player at the correct location in the tables based on order of 
          //ascending player number. Unless the insert location is at the end, this 
          //requires shifting existing players down in order to make room 
          static void InsertPlayer(Int32 number, String lastName, Int32 points,
              Int32[] playerNumbers, String[] playerLastNames, Int32[] playerPoints,
              ref Int32 playerCount)
          {
              /* PUTS DATA IN NEXT AVALIABLE SLOT
              playerNumbers[playerCount] = number;
              playerLastNames[playerCount] = lastName;
              playerPoints[playerCount] = points;
              playerCount++;
              */
  
              // PUTS DATA IN PLAYER ASECENDING ORDER
              Int32 insertIndex, shiftCount;
              insertIndex = GetInsertIndex(number, playerNumbers, playerCount);
              for (shiftCount = playerCount; shiftCount &gt; insertIndex; shiftCount--)
              {
                  playerNumbers[shiftCount] = playerNumbers[shiftCount - 1];
                  playerLastNames[shiftCount] = playerLastNames[shiftCount - 1];
                  playerPoints[shiftCount] = playerPoints[shiftCount - 1];
              }
              playerNumbers[insertIndex] = number;
              playerLastNames[insertIndex] = lastName;
              playerPoints[insertIndex] = points;
              playerCount++;
  
          }
          //Returns the index of the first player number in the table that is greater
          //than the player number to be inserted
          static Int32 GetInsertIndex(Int32 playerNumber, Int32[] playerNumbers,
              Int32 playerCount)
          {
              Int32 index = 0;
              bool found = false;
              while (index &lt; playerCount &amp;&amp; found == false)
                  if (playerNumbers[index] &gt; playerNumber)
                      found = true;
                  else
                      index++;
              return index;
          }
  
          //Returns the index of the player number in the table 
          //or -1 if the number is not found
          static Int32 GetPlayerIndex(Int32 playerNumber,
              Int32[] playerNumbers, Int32 playerCount)
          {
              Int32 index = 0;
              bool found = false;
              while (index &lt; playerCount &amp;&amp; found == false)
                  if (playerNumbers[index] == playerNumber)
                      found = true;
                  else
                      index++;
              if (found == false)
                  index = -1;
              return index;
          }
  
          //Lists the players in the tables
          static void ProcessList(Int32[] playerNumbers, String[] playerLastNames,
              Int32[] playerPoints, Int32 playerCount)
          {
  
              if (playerCount &gt; 0)
              {
                  Console.WriteLine("\n{0,7}   {1,-25}{2,6}\n", "Number", "Last Name", "Points");
                  for (Int32 player = 0; player &lt; playerCount; player++)
                      Console.WriteLine("{0,7}   {1,-25}{2,6}", playerNumbers[player], playerLastNames[player], playerPoints[player]);
              }
              else
                  Console.WriteLine("\nList Players: the roster is empty");
          }
  
          //Returns a positive integer
          static Int32 GetPositiveInteger(String prompt)
          {
              Int32 n;
              Console.WriteLine(prompt);
              n = Int32.Parse(Console.ReadLine());
              while (n &lt; 0)
              {
                  Console.WriteLine("\nError: enter positive value");
                  Console.WriteLine(prompt);
                  n = Int32.Parse(Console.ReadLine());
              }
              return n;
          }
  
          //Returns a non-empty string
          static String GetString(String prompt)
          {
              String returnString;
              Console.WriteLine(prompt);
              returnString = Console.ReadLine();
              while (returnString == "")
              {
                  Console.WriteLine("\nError: must enter keyboard data");
                  Console.WriteLine(prompt);
                  returnString = Console.ReadLine();
              }
              return returnString;
          }
          // retrieve single value from an array
  
          //static void ProcessRetrieve(Int32[] playerNumbers, String[] playerLastNames
          //, Int32[] playerPoints, Int32 playerCount)
          //{
  
          //}
  </code></pre>
  
  <p>So right here i begin the process of retrieving the a single entry which works and is a function that i can reuse by modifying to work with the next two functions.</p>
  
  <pre><code>        static void ProcessRetrieve(Int32[] playerNumbers, String[] playerLastNames,
              Int32[] playerPoints, ref Int32 playerCount, Int32 MAXPLAYERS)
          {
              int player;// Player number to find
              int playerindex;//index of the player number in Array
              if (playerCount &lt; MAXPLAYERS)
              {
                  player = GetPositiveInteger("\nRetrieve Player: please enter the player's number"); //JG I used the same mechanism when you are creating the record, when you create yu check if it exists
                  /** If it exists you say record exists in this case I said display the existing record**/
                  playerindex = GetPlayerIndex(player, playerNumbers, playerCount);
                  if (playerindex != -1)// !-1 means Does not exist JG
                  {
  
                      Console.WriteLine("{0,7}   {1,-25}{2,6}", playerNumbers[playerindex], playerLastNames[playerindex], playerPoints[playerindex]);
                      Console.WriteLine();
                  }
                  else
                      Console.WriteLine("\nRetrieve Player: the player number does not exists");
              }
              else
                  Console.WriteLine("\nRetrieve Player: the player does not exist in the roster");
          }
  </code></pre>
  
  <p>Now here is where i'm having difficulty, how do i make this code update instead of retrieve i'm absolutely lost here and i've looked into many articles and only found how to change the array through the code instead of with user input</p>
  
  <pre><code>        static void ProcessUpdate(Int32[] playerNumbers,
          string[] playerLastnames, Int32[] playerpoints, Int32 playerCounts, Int32 MAXPLAYERS)
          {
              int player;// Player number to find
              int playerindex;//index of the player number in Array
              if (playerCounts &lt; MAXPLAYERS || playerCounts == MAXPLAYERS)
              {
                  player = GetPositiveInteger("\nUpdate Player: please enter the player's number");
                  playerindex = GetPlayerIndex(player, playerNumbers, playerCounts);
                  if (playerindex != -1)
                  {
  
                      Console.WriteLine("{0,7}   {1,-25}{2,6}", playerNumbers[playerindex], playerLastnames[playerindex], playerpoints[playerindex]);
                      Console.WriteLine();
                  }
                  else
                      Console.WriteLine("\nUpdate Player: the player number does not exists");
              }
              else
                  Console.WriteLine("\nUpdate Player: the player does not exist in the roster");
          }
  
      }
  }
  </code></pre>