C#

public void Extract()
        {
            String Fname = openFileDialog2.FileName;
            int counter = 0;
            string line;
            

            var BDate = ("BLAST DRIVER ON");
            var Dets = ("BLAST SUMMARY");
            var BPlan = ("BLASTING PLAN");
            
            
            System.IO.StreamReader file = new System.IO.StreamReader(Fname);

            while ((line = file.ReadLine()) != null)
            {
                if (line.EndsWith(BDate) | line.Contains(Dets) | line.Contains(BPlan))
                {
                    listBox1.Items.Add(line);
                }
                
                    counter++;
                }
            }

List<string> lines = new List<string>();
 using (var sr = new StreamReader("file.txt"))
 {
      while (sr.Peek() >= 0)
          lines.Add(sr.ReadLine());
 }


for (int i = 0; i < lines.Count; i++)
{
   if (lines(i).contains(Dets)) {
	listbox.Items.Add(lines(i + 1));
   }
}

using System;
using System.IO;
using System.Runtime.Serialization;

namespace MasterBlaster
{
    [DataContract]
    public class Blast
    {
        //>17/05/15-16:40:13:BLAST DRIVER ONic DateTime BlastDriveerOn { set; get; }
        [DataMember]
        public string BlastId { set; get; }

        [DataMember]
        public DateTime BlastTime { set; get; }

        //>PU1053(0005 DETS):
        [DataMember]
        public int BlastInitialDets { set; get; }

        //>1/7B7C35;11/7B70B2;21/7B7058;31/7B83A1;41/7B70D1;
        [DataMember]
        public string[] BlastInitialData { set; get; }
        
        // will not be serialized !
        public string tempInfo;

        public Blast(string id, int idets, params string[] idata)
        {
            BlastId = id;
            BlastInitialDets = idets;
            BlastInitialData = idata;
        }
        
        // keep going ...
        
        // define a serializer
        public static class BlastsSerializer
        {
            static DataContractSerializer dcs = new DataContractSerializer(typeof(Blast[]));

            public static void Serialize(string filepath, Blast[] blasts)
            {
              // will create necessary folder structure if it does not exist
    Directory.CreateDirectory(Path.GetDirectoryName(filepath));
                
                using (var writer = new FileStream(filepath, FileMode.Open, FileAccess.Write))
                {
                    dcs.WriteObject(writer, blasts);
                }
            }

            public static Blast[] DeSerialize(string filepath)
            {
                Blast[] blasts;
                
                using (var reader = new FileStream(filepath, FileMode.Open, FileAccess.Read))
                {
                    blasts = dcs.ReadObject(reader) as Blast[];
                }
 
                return blasts;
            }
        }
    }
}

public static string JoinLines(this IEnumerable<string> lines) => string.Join(Environment.NewLine, lines);

void RemoveDuplicatesButton_Click(object sender, RoutedEventArgs e) => this.InputTextBox.Text = this.InputTextBox.Text.SplitLines().Unique().JoinLines();

Kevin Li (Li, Ken-un) wrote:

but at which point should I have stopped for this example?

Kevin Li (Li, Ken-un) wrote:

Should I perhaps switch to another programming language that’s more conducive to this style of writing?

SortedSet<string> seen = new SortedSet<string>();
foreach (string line in longString.Split('\r', '\n'))
{
  seen.Add(line);
}
return string.Join(Environment.NewLine, seen);

.maxstack 5
.locals init (
    [0] class [System]System.Collections.Generic.SortedSet`1<string> seen,
    [1] string[] strArray,
    [2] int32 num,
    [3] string line,
    [4] string str)
L_0000: nop
L_0001: newobj instance void [System]System.Collections.Generic.SortedSet`1<string>::.ctor()
L_0006: stloc.0
L_0007: nop
L_0008: ldarg.1
L_0009: ldc.i4.2
L_000a: newarr char
L_000f: dup
L_0010: ldc.i4.0
L_0011: ldc.i4.s 13
L_0013: stelem.i2
L_0014: dup
L_0015: ldc.i4.1
L_0016: ldc.i4.s 10
L_0018: stelem.i2
L_0019: callvirt instance string[] [mscorlib]System.String::Split(char[])
L_001e: stloc.1
L_001f: ldc.i4.0
L_0020: stloc.2
L_0021: br.s L_0035
L_0023: ldloc.1
L_0024: ldloc.2
L_0025: ldelem.ref
L_0026: stloc.3
L_0027: nop
L_0028: ldloc.0
L_0029: ldloc.3
L_002a: callvirt instance bool [System]System.Collections.Generic.SortedSet`1<string>::Add(!0)
L_002f: pop
L_0030: nop
L_0031: ldloc.2
L_0032: ldc.i4.1
L_0033: add
L_0034: stloc.2
L_0035: ldloc.2
L_0036: ldloc.1
L_0037: ldlen
L_0038: conv.i4
L_0039: blt.s L_0023
L_003b: call string [mscorlib]System.Environment::get_NewLine()
L_0040: ldloc.0
L_0041: call string [mscorlib]System.String::Join(string, class [mscorlib]System.Collections.Generic.IEnumerable`1<string>)
L_0046: stloc.s str
L_0048: br.s L_004a
L_004a: ldloc.s str
L_004c: ret

void RemoveDuplicatesButton_Click(object sender, RoutedEventArgs e) => this.InputTextBox.Text = string.Join(Environment.NewLine, new SortedSet<string>(longString.Split('\r', '\n')));

textBox1.Lines = textBox1.Lines.Distinct().OrderBy(str => str).ToArray();

Rob Philpott wrote:

If you drop the OrderBy(), I think there are no guarantees about preserving order.

static IEnumerable<TSource> DistinctIterator<TSource>(IEnumerable<TSource> source, IEqualityComparer<TSource> comparer) {
    Set<TSource> set = new Set<TSource>(comparer);
    foreach (TSource element in source)
        if (set.Add(element)) yield return element;
}