static void Main(string[] args)
        {
            try
            {
				//AsyncContext- класс для запуска асинхронных методов в консольном приложении
                
				AsyncContext.Run(async () => await AsyncLoadUrlParallel());
           
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message); 
                Console.ReadKey();
            }
        }
		
		
		
		 private static   async Task AsyncLoadUrlParallel()
        {
            IEnumerable<string> urlist = getliststring();
            List<Task> tasklist = new List<Task>();

        var tasks = Parallel.ForEach(urlist,
        async s =>
        {
             Console.WriteLine(s + "--" + await ReadXmlValueAsyncTask(s));
            await ReadXmlValueAsyncTask(s);

        });
		
		
		       private  static  IEnumerable<string> getliststring()
        {
            DateTime start_date = new DateTime(2017, 01, 01);
            DateTime final_date = DateTime.Today;

            CultureInfo culture = CultureInfo.CreateSpecificCulture("ru-RU");
            DateTimeFormatInfo dtfi = culture.DateTimeFormat;
            dtfi.DateSeparator = "/";

            List<string> list_of_url = new List<string>();

			//DateTimeHelper.EachDay- получаем дату каждого дня во временном интервале
            foreach (DateTime day in DateTimeHelper.EachDay(start_date, final_date))
            {
                string xml_path = "http://www.cbr.ru/scripts/XML_daily.asp?date_req=" + day.ToString("dd/MM/yyyy", dtfi); 
                list_of_url.Add(xml_path);

            }
            return list_of_url;

        }
		
		
		 static async Task<decimal> ReadXmlValueAsyncTask(string inputpath)
        {
            decimal p = 0;
            using (XmlReader r = XmlReader.Create(inputpath, new XmlReaderSettings() { Async = true }))
            {
                while (await r.ReadAsync())
                {
                    if (r.NodeType == XmlNodeType.Element)
                    {
                        if (r.LocalName == "Valute")
                        {
                            if (r.GetAttribute("ID") == "R01239")
                            {
                                r.ReadToFollowing("Value");
                                string ps = (string)await r.ReadElementContentAsAsync(typeof(System.String), null);
                                p = Convert.ToDecimal(ps);
                            }
                        }
                    }
                }
            }
            return p;
        }
		
		
	// последовательный вариант загрузки 
 static void Main(string[] args)
	{
            try
            {
                DateTime start_date = new DateTime(2017, 01, 01);
                DateTime final_date = DateTime.Today;

                CultureInfo culture = CultureInfo.CreateSpecificCulture("ru-RU");
                DateTimeFormatInfo dtfi = culture.DateTimeFormat;
                dtfi.DateSeparator = "/";

                foreach (DateTime day in DateTimeHelper.EachDay(start_date, final_date))
                {
                        string xml_path = "http://www.cbr.ru/scripts/XML_daily.asp?date_req=" + day.ToString("dd/MM/yyyy", dtfi);
                       Console.WriteLine(day.ToString("dd/MM/yyyy", dtfi) + "  " + AsyncContext.Run(() => ReadXmlValueAsyncTask(xml_path)));

                }         
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message); 
                Console.ReadKey();
            }
        }
	

// метод с "многопоточной обработкой"
 public async static Task parse_outAsync(string s)
        {
            using (FileStream sourceStream = new FileStream(s,
            FileMode.Open, FileAccess.Read, FileShare.Read,
            bufferSize: 4096, useAsync: true))
            {
                StringBuilder sb = new StringBuilder();
                byte[] buffer = new byte[0x1000];
                int numRead;
                while ((numRead = await sourceStream.ReadAsync(buffer, 0, buffer.Length)) != 0)
                {
                    string text = Encoding.ASCII.GetString(buffer, 0, numRead);
                    sb.Append(Encoding.ASCII.GetString(buffer, 0, numRead));
                }

                string a = sb.ToString();
                string[] str = a.Split('\n');

                List<Task> tasks = new List<Task>();
				
                object sync = new object();

                Parallel.ForEach(str, (currentitem) =>
                {
                    if (!String.IsNullOrEmpty(currentitem) && !String.IsNullOrWhiteSpace(currentitem))
                        lock (sync)
                        {
                            tasks.Add(Task.Factory.StartNew(() =>
                            {
      

                                Int64 id = default(Int64);
                                string auth_comment = null;
                                string auth_code = null;
                                int i_final = default(int);
                                int i_start = default(Int16);

                                i_final = currentitem.LastIndexOf(",");
                                // ищем позицию последней запятой

                                for (int i = i_final - 1; i >= 1; i += -1)
                                {
                                    if (currentitem.Substring(i, 1) == ",")
                                    {
                                        i_start = i;
                                        break;
                                    }
                                }

                                auth_code = currentitem.Substring(StringHelper.my_instr(currentitem, ",", 5) + 1, StringHelper.my_instr(currentitem, ",", 6) - StringHelper.my_instr(currentitem, ",", 5) - 1);
                                auth_comment = currentitem.Substring(i_start + 1, i_final - i_start - 1);

                                //ищем id 
                                id = Convert.ToInt32(currentitem.Substring(i_final + 1, currentitem.Length - i_final - 1));

                                if (auth_code.Contains(",") || auth_comment.Contains(","))
                                {
                                    Console.WriteLine("Неправильный парсинг");
                                    return;
                                }

                                using (SqlConnection con = new SqlConnection(@"Server=MSSQL;
                                   Database = DataBase;
                                   User Id = user;
                                   Password = u1;
                                   pooling = true"))
                                {
                                    using (SqlCommand cmd = new SqlCommand())
                                    {
                                        cmd.CommandText = "sp";
                                        cmd.CommandType = CommandType.StoredProcedure;
                                        cmd.Parameters.AddWithValue("@id", id);
                                        cmd.Parameters.AddWithValue("@coment", auth_comment);
                                        cmd.Parameters.AddWithValue("@code", auth_code);
                                        cmd.Connection = con;

                                        try
                                        {
                                            if (con.State != ConnectionState.Open)
                                                con.Open();
                                           //  await cmd.ExecuteNonQueryAsync();
                                        }
                                        finally
                                        {
                                            if (con.State != ConnectionState.Closed)
                                                con.Close();
                                        }
                                    }
                                }

                            }));
                        }                       
                }
              );

                Task.WaitAll(tasks.ToArray());
            }
        }

//однопоточная версия

  public  async static Task  parse_out(string s)
        {
          
            Int64 id = default(Int64);
            string auth_comment = null;
            string auth_code = null;
            int i_final = default(int);
            int i_start = default(Int16);

            using (StreamReader reader = new StreamReader(s, System.Text.Encoding.ASCII))
            {
                while (reader.Peek() >= 0)
                {
                    string str = reader.ReadLine();
                    i_final = str.LastIndexOf(",");
                    // ищем позицию последней запятой

                    for (int i = i_final - 1; i >= 1; i += -1)
                    {
                        if (str.Substring(i, 1) == ",")
                        {
                            i_start = i;
                            break;
                        }
                    }

                    auth_code = str.Substring(StringHelper.my_instr(str, ",", 5)+1, StringHelper.my_instr(str, ",", 6)- StringHelper.my_instr(str, ",", 5)-1);
                    auth_comment = str.Substring(i_start + 1, i_final - i_start - 1);

                    //ищем id 
                    id = Convert.ToInt32(str.Substring(i_final + 1, str.Length - i_final - 1));

                    if (auth_code.Contains(",") || auth_comment.Contains(","))
                    {
                        Console.WriteLine("Неправильный парсинг"); 
                        return;
                    }

                    using (SqlConnection con = new SqlConnection(@"Server=MSSQL;
                                   Database = DataBase;
                                   User Id = user;
                                   Password = u1;
                                   pooling = true"))
                    {
                        using (SqlCommand cmd = new SqlCommand())
                        {
                            cmd.CommandText = "sp";
                            cmd.CommandType = CommandType.StoredProcedure;
                            cmd.Parameters.AddWithValue("@id", id);
                            cmd.Parameters.AddWithValue("@coment", auth_comment);
                            cmd.Parameters.AddWithValue("@auth_code", auth_code);
                            cmd.Connection = con;

                            try
                            {
                                if (con.State != ConnectionState.Open)
                                   con.Open();
                                // await cmd.ExecuteNonQueryAsync();
                            }
                            finally
                            {
                                if (con.State != ConnectionState.Closed)
                                    con.Close();
                            }
                        }
                    }
                }
            }    
        }