Как использовать оперативную память рационально?

List<string> iskl1 = new List<string>();
            List<string> isklob = new List<string>();
            StreamReader sr1iskl = new StreamReader("D:\\Program\\farVariant.txt");
            string stroka1;
            while ((stroka1 = sr1iskl.ReadLine()) != null)
            { iskl1.Add(stroka1); }
            List<string> iskl2 = new List<string>();
            StreamReader sr2iskl = new StreamReader("D:\\Program\\IskVariantOB.txt");
            string stroka2;
            while ((stroka2 = sr2iskl.ReadLine()) != null)
            { iskl2.Add(stroka2); }
            for (int j = 0; j < iskl1.Count; j++)
            {
                for (int i = 0; i < iskl2.Count; i++)
                {
                    if (iskl1[j] != iskl2[i])
                    {
                        isklob.Add(iskl1[j]);
                    }
                }
 
            } File.WriteAllLines("D:\\Program\\variantfinal.txt", isklob);

using System;
using System;
using System.Collections.Generic;
using System.Text;
 
namespace EnumerableDemo.Bad
{
 public class StringTransformer
 {
  IDictionary<string, string> _catalog = new Dictionary<string, string>
  {
   {"012345", "Car"},
   {"012346", "Bus"},
   {"012347", "Train"}
  };
 
  public StringTransformer()
  {
   _catalog.Add("%Date%", DateTime.Now.ToString("d"));
  }
 
  public IList<string> Transform(IList<string> strs)
  {
   var list = new List<string>();
 
   foreach (var item in strs)
   {
    var builder = new StringBuilder(item);
    foreach (var key in _catalog.Keys)
    {
     builder.Replace(key, _catalog[key]);
    }
    list.Add(builder.ToString());
   }
 
   return list;
  }
 }
}

using System;
using System.Collections.Generic;
using System.IO;
 
namespace EnumerableDemo.Good
{
 class MainClass
 {
  public static IEnumerable<string> ReadInput()
  {
   using (var file = File.OpenText("input.txt"))
   {
    while (!file.EndOfStream)
    {
     yield return file.ReadLine();
    }
   }
  }
 
  public static void WriteOutput(IEnumerable<string> strs)
  {
   using (var file = File.CreateText("output.txt"))
   {
    foreach (var str in strs)
    {
     file.WriteLine(str);
    }
   }
  }
 
  public static void Main(string[] args)
  {
   var stringTransformer = new StringTransformer();
   var input = ReadInput().Where(str=>str.Length > 5);
   var transformed = stringTransformer.Transform(input);
   WriteOutput(transformed);
  }
 }
}

using System.Collections.Generic;
using System.IO;
using System.Linq;
 
namespace ConsoleApplication7
{
    public class Logic
    {
        private IEnumerable<string> GetLines(StreamReader reader)
        {
            while (!reader.EndOfStream)
                yield return reader.ReadLine();
        }
 
        public IEnumerable<string> GetHashLines(StreamReader reader)
        {
            while (!reader.EndOfStream)
            {
                var str = reader.ReadLine();
                yield return str.Substring(0, 10);
            }
        }
 
        public Dictionary<string, List<uint>> GetFirstData(string filename)
        {
            uint index = 0;
            var result = new Dictionary<string, List<uint>>();
            using (var reader = File.OpenText(filename))
            foreach (var key in GetHashLines(reader))
            {
                if (!result.ContainsKey(key))
                    result[key] = new List<uint>();
                result[key].Add(index++);
            }
            return result;
        }
        public HashSet<string> GetSecondData(string filename)
        {
            HashSet<string> result;
            using (var reader = File.OpenText(filename))
            {
                result = new HashSet<string>(GetHashLines(reader));
            }
            return result;
        }
 
        public void ProcessingFiles(string firstFile, string secondFile, string resultFile, int minCountLine, int maxCountLine)
        {
            var firstData = GetFirstData(firstFile);
            var secondData = GetSecondData(secondFile);
            secondData.IntersectWith(firstData.Keys);
            var thirdData =
                secondData.Select(x => firstData[x])
                    .Where(y => y.Count >= minCountLine && y.Count <= maxCountLine).Select(z => z[0])
                    .ToList();
            int index = 0;
            uint lineNumber = 0;
            using (var reader = File.OpenText(firstFile))
            using (var writer = File.CreateText(resultFile))
                foreach (string line in GetLines(reader))
                {
                    if (lineNumber == thirdData[index])
                    {
                        writer.WriteLine(line);
                        index++;
                    }
                    if (index == thirdData.Count) break;
                    lineNumber++;
                }
        }
    }
}

using System;
 
namespace ConsoleApplication7
{
    class Program
    {
        static void Main(string[] args)
        {
            var logic = new Logic();
            logic.ProcessingFiles("file1.txt","file2.txt","result.txt", 100,1000000);
            Console.ReadKey();
        }
    }
}

public void ProcessingFiles(string firstFile, string secondFile, string resultFile, int minCountLine, int maxCountLine)
        {
            var firstData = GetFirstData(firstFile);
            var secondData = GetSecondData(secondFile);
            secondData.IntersectWith(firstData.Keys);
            var thirdData =
                secondData.Select(x => firstData[x])
                    .Where(y => y.Count >= minCountLine && y.Count <= maxCountLine).Select(z => z[0])
                    .ToList();

public IEnumerable<string> GetHashLines(StreamReader reader)
        {
            while (!reader.EndOfStream)
            {
                var str = reader.ReadLine();
                yield return str.Substring(0, 10);
            }
        }

                        var s1 = list1[j];
                        var s2 = list2[i];
                        
                        for (int k = 0; k < 17; k++)
                        {
                            if (s1[k] == s2[k])
                            {
                                s++;
                            }
                        }