title: Why is Console.Readline not executing as expected
body: <p>I have the following code below to work with. The problem I have here is that the code runs through the while loop without waiting for input on the line <strong>String temp =  Console.ReadLine()</strong> . Need help understanding why and how to fix please. Thanks in advance!</p>
  
  <pre><code>   /*Banker's algorithm Implementation*/
    class Program
    {
  
          static void Main(string[] args)
          {
                int n = 0;//number of resources we will  be dealing with
                int proc_num = 0;//Total number of processes to share available resources
  
                IDictionary&lt;String, SysProcess&gt; processes = new Dictionary&lt;String, SysProcess&gt;();
                IDictionary&lt;String, int&gt; MaxR = new Dictionary&lt;String, int&gt;();// maximum available resources
                IDictionary&lt;String, int&gt; avail = new Dictionary&lt;String, int&gt;();// Available resources after first allocation
                Dictionary&lt;String, int&gt; availsum = new Dictionary&lt;string, int&gt;();
  
                //Start  
                while (true)
                {
                      Console.WriteLine(" What is number of resources to be shared? : ");
                            if (!int.TryParse(Console.ReadLine(), out n))
                            {
                                  Console.WriteLine(" Error Please provide valid number --- {0}!", n);
                            }
                            else
                            {
                                  break;
                            }
                }
  
                //get the maximum number of each Resources Ie Total Resources Available
                while (true &amp;&amp; n&gt;0)
                {
                      Console.WriteLine("Using a comma delimited list(e.g. 0, 0, 0, 0) list maximum of each of the {0} resources : ", n);
                      String temp;
                        temp = Console.ReadLine();
  
                      if (!String.IsNullOrEmpty(temp))
                      {
                            String[] maxR = temp.Split(',');
                            for (int a = 1; a &lt;= n; a++)
                            {
                                  MaxR.Add("Resource#" + a.ToString(), Convert.ToInt32(maxR[a]));
                            }
                            break;
                      }
                }
  
  
                while (true &amp;&amp; n&gt;0)
                {
                      Console.Write("Enter total number of processes to share the available resources :");
                      if (!int.TryParse(Console.Read().ToString(), out proc_num))
                      {
                            Console.WriteLine(" Error Please provide valid number --- {0}!", proc_num);
                      }
                      else
                      { break; }
                }
  
                if(proc_num &gt; 0)
                {
                      //Request Process Max and allocated resources data
                      for (int i = 1; i &lt;= proc_num; i++)
                      {
                            Console.Write("Using a comma delimited list, Enter total number of Resources 1 through {0} are needed by PROCESS#{1} ?", n, i);
                            String[] temps = Console.ReadLine().Split(',');
                            SysProcess tempproc = new SysProcess("Process#" + i.ToString());
  
                            for (int a = 0; a &lt; temps.Length; a++)
                            {
                                  tempproc.Add_max_resource("Resource#" + (a + 1).ToString(), Convert.ToInt32(temps[a]));
                            }
  
                            //How many resources have already been allocated to each resource
                            temps = null;
                            Console.Write("Using a comma delimited list,Enter number of resources 1 through {0} already  allocated to PROCESS#{1} ? ", n, i);
                            temps = Console.ReadLine().Split(',');
                            for (int a = 0; a &lt; temps.Length; a++)
                            {
                                  tempproc.add_alloc_resource("Resource#" + (a + 1).ToString(), Convert.ToInt32(temps[a]));
                            }
                            processes.Add("Process#" + i.ToString(), tempproc);
                      }
  
  
                      Console.WriteLine("Processing . . . ");
                      Console.WriteLine();
                      Console.WriteLine("Available resources ");
  
                      //Compute Available Resources 
                      for (int i = 0; i &lt; n; i++)
                      {
                            if (!availsum.ContainsKey("Resource#" + (i + 1).ToString()))
                                  availsum.Add("Resource#" + (i + 1).ToString(), 0);
                            foreach (SysProcess sp in processes.Values)
                            {     //add sum up the available
                                  availsum["Resource#" + (i + 1).ToString()] += sp.alloc_resources["Resource#" + (i + 1).ToString()];
                            }
                      }
  
                      //print out the availables we computed 
  
                      Console.Write(" avail&lt; ");
                      for (int j = 0; j &lt; n; j++)
                      {
  
                            Console.Write(availsum["Resource#" + (j + 1).ToString()] + ",");
  
                            if (j + 1 == n)//if this is the last one, go ahead and output the rest
                                  Console.Write("{0} &gt; ", availsum["Resource#" + (j + 1).ToString()]);
                      }
  
  
                      // Printing resources still needed 
                      Console.WriteLine();
                      foreach (SysProcess p in processes.Values)
                      {
                            p.print_needed();
                      }
  
  
                      //a) Find a row in the Need matrix which is less than the Available vector. 
                      //If such a row exists, then the process represented by that row may complete
                      //with those additional resources. If no such row exists, eventual deadlock is possible.
                      Dictionary&lt;String, int&gt; _currentavailsum;
  
                      foreach (SysProcess p in processes.Values)
                      {
                            int TotalSproccounter = 0;
                            String safelead;
                            if (isprocessSafe(n, p, availsum))
                            {
                                  TotalSproccounter++;
                                  safelead = p.id;
                                  _currentavailsum = new Dictionary&lt;String, int&gt;();
                                  _currentavailsum = availsum;//get a copy of the original data to begin with
                                  foreach (SysProcess q in processes.Values)
                                  {
                                        if (q != p)//we only want to compare with the others from here
                                        {
                                              if (isprocessSafe(n, p, _currentavailsum))
                                              {
                                                    update_availsum(n, q, ref  _currentavailsum);//update the currentavail count
                                                    TotalSproccounter++;
                                                    //update print 
                                                    safelead += ", " + q.id;
                                              }
                                        }
                                  }
  
                                  if (TotalSproccounter == proc_num)
                                  {
                                        Console.WriteLine("Safe allocation &lt; {0} &gt;", safelead);
                                  }
                                  else
                                  {
                                        Console.WriteLine("Deadlock reached/unsafe allocation :  &lt; {0} &gt;", safelead);
                                  }
                            }
                      }
                 }
                Console.ReadLine();
          }
  
          //compares the number of resources needed against the number of resources available
          public static Boolean isprocessSafe(int n, SysProcess p, IDictionary&lt;String, int&gt; avail)
          {
                int safecount = 0;
                foreach (String resourcekey in avail.Keys)
                {
                      if (p.need_resources.ContainsKey(resourcekey) &amp;&amp; p.need_resources[resourcekey] &lt;= avail[resourcekey])
                      {
                            safecount++;
                      }
  
                }
                if (safecount == n)
                {
  
                      return true;
                }
                return false;
          }
  
          //compares the number of resources needed against the number of resources available
          public static void update_availsum(int n, SysProcess p, ref Dictionary&lt;String, int&gt; _currentavailsum)
          {
                foreach (String resourcekey in _currentavailsum.Keys)
                {
                      if (p.need_resources.ContainsKey(resourcekey))
                      {
                            _currentavailsum[resourcekey] += p.need_resources[resourcekey];
                      }
  
                }
          }
  
    }
  
    //container class for processes 
    public class SysProcess
    {
          public String id { get; set; }
          Dictionary&lt;String, int&gt; _max_resources = null; // will hold the Resource name and the  the number of resources 
          Dictionary&lt;String, int&gt; _alloc_resources = null;//allocated resources
          Dictionary&lt;String, int&gt; _need_resources = null;//allocated resources
  
          public Dictionary&lt;String, int&gt; max_resources
          {
                get
                { return _max_resources; }
  
          }
  
          public Dictionary&lt;String, int&gt; alloc_resources
          {
                get
                {
                      return _alloc_resources;
  
                }
          }
  
          public Dictionary&lt;String, int&gt; need_resources
          {
                get
                {
                      return _need_resources;
  
                }
          }
  
          public SysProcess(String procID)
          {
                _max_resources = new Dictionary&lt;String, int&gt;();
                _alloc_resources = new Dictionary&lt;String, int&gt;();
                id = procID;
          }
  
          public void Add_max_resource(String resource, int count)
          {
                _max_resources.Add(resource, count);
          }
  
          public void add_alloc_resource(String resource, int count)
          {
                _alloc_resources.Add(resource, count);
                _need_resources.Add(resource, _max_resources[resource] - alloc_resources[resource]);
          }
  
          public void print_needed()
          {
                Console.Write(id);
                foreach (int s in _need_resources.Values)
                {
                      Console.Write(" {0}", s);
                }
  
          }
    }
  </code></pre>
  
  <p>Probably a good idea to add the whole code here since I am still unable to figure this one out. Please help </p>