C#

public sealed class FlatFileLine
{
    private sealed class MetaData
    {
        public readonly int? SampleID;
        public readonly int? RepNo;
        public readonly int? Protein;
        public readonly int? TS;
        public readonly int? Fat;
        
        public MetaData(string[] fields)
        {
            for (int index = 0; index < fields.Length; index++)
            {
                string field = fields[index].Trim();
                if (string.Equals(field, "sampleID", StringComparison.OrdinalIgnoreCase))
                {
                    SampleID = index;
                }
                else if (string.Equals(field, "rep#", StringComparison.OrdinalIgnoreCase))
                {
                    RepNo = index;
                }
                else if (string.Equals(field, "protein", StringComparison.OrdinalIgnoreCase))
                {
                    Protein = index;
                }
                else if (string.Equals(field, "TS", StringComparison.OrdinalIgnoreCase))
                {
                    TS = index;
                }
                else if (string.Equals(field, "Fat", StringComparison.OrdinalIgnoreCase))
                {
                    Fat = index;
                }
            }
        }
    }
    
    public string SampleID { get; private set; }
    public string RepNo { get; private set; }
    public string Protein { get; private set; }
    public string TS { get; private set; }
    public string Fat { get; private set; }
    
    public static IEnumerable<FlatFileLine> ParseFile(TextReader reader, string delimiter)
    {
        if (reader == null) throw new ArgumentNullException("reader");
        return ParseLines(ReadLines(reader, delimiter));
    }
    
    private static IEnumerable<string[]> ReadLines(TextReader reader, string delimiter)
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            yield return line.Split(new[] { delimiter }, StringSplitOptions.None);
        }
    }
    
    private static IEnumerable<FlatFileLine> ParseLines(IEnumerable<string[]> lines)
    {
        MetaData columns = null;
        foreach (string[] fields in lines)
        {
            if (columns == null)
            {
                columns = new MetaData(fields);
            }
            else
            {
                yield return new FlatFileLine(fields, columns);
            }
        }
    }
    
    private FlatFileLine(string[] fields, MetaData columns)
    {
        if (columns.SampleID < fields.Length)
        {
            SampleID = fields[columns.SampleID.Value];
        }
        if (columns.RepNo < fields.Length)
        {
            RepNo = fields[columns.RepNo.Value];
        }
        if (columns.Protein < fields.Length)
        {
            Protein = fields[columns.Protein.Value];
        }
        if (columns.TS < fields.Length)
        {
            TS = fields[columns.TS.Value];
        }
        if (columns.Fat < fields.Length)
        {
            Fat = fields[columns.Fat.Value];
        }
    }
}

public void Main()
{
    string delimiter = Dts.Variables["User::Delimiter"].Value.ToString();
    string TableName = Dts.Variables["User::TableName"].Value.ToString();
    string SourceDirectory = Dts.Variables["User::SourceFolder"].Value.ToString();
    
    string query = @"INSERT INTO [" + TableName + "] (sampleID, [rep#], protein, TS, Fat) VALUES (@sampleID, @RepNo, @protein, @TS, @Fat)";
    
    using (SqlConnection connection = Dts.Connections["BIReports"].AcquireConnection(Dts.Transaction))
    using (SqlCommand command = new SqlCommand(query, connection))
    {
        foreach (string fileName = Directory.EnumerateFiles(SourceDirectory))
        {
            using (StreamReader reader = File.OpenText(fileName))
            {
                foreach (FlatFileLine line in FlatFileLine.ParseFile(reader, delimiter))
                {
                    command.Parameters.Clear();
                    command.Parameters.AddWithValue("@sampleID", line.SampleID ?? string.Empty);
                    command.Parameters.AddWithValue("@RepNo", line.RepNo ?? string.Empty);
                    command.Parameters.AddWithValue("@protein", line.Protein ?? string.Empty);
                    command.Parameters.AddWithValue("@TS", line.TS ?? string.Empty);
                    command.Parameters.AddWithValue("@Fat", line.Fat ?? string.Empty);
                    command.ExecuteNonQuery();
                }
            }
        }
    }
    
    Dts.TaskResult = (int)ScriptResults.Success;
}

ev.Graphics.DrawString("MyText", new Font("Arial", /* Point size: => */ 18, FontStyle.Bold), new SolidBrush(Color.Black), new PointF(15, 125));

using (var arial20Bold = new Font("Arial", 20, FontStyle.Bold))
using (var solidBlack = new SolidBrush(Color.Black))
{
    ev.Graphics.DrawString("MyText", arial20Bold, solidBlack, new PointF(15, 125));
}