C# string forming ballots

the issue here is not how to make it readable, I'm just concerned about the overall string memory allocation for this application. As it seems there are a lot of similar string concatenation else where, which is something you need to worry about. There are better methods to reduce string memory allocation and also improve code readability, but again, depends on your current project status and how much efforts you will put on it, and is it going to be worth that efforts? or is there any plan to upgrade or change the application ?! ...etc. many questions and thoughts around changes like that. So, you decide which is better.

For this code and any future code, I would like to share one way to hold this kind of issues.

Whenever you need to build an output to the consumer as string, it would be best if you first build a class model for that output, to hold the object values, which can be reused. Then, use that model to represent the output in any presentation format you like such as normal text, csv, JSON, pdf, html ..etc. All can use the same object to reproduce the same exact result in different format. It's also maintainable, and would give you the ability to move the presentation logic into its layer.

Here is an example :

public sealed class IPOTape
{
    private readonly int _ipo;
    private readonly string _tapeNumber;
    
    public int IPO => _ipo;
    
    public string TapeNumber => _tapeNumber;
    
    public IPOTape(int ipo, string tapeNumber)
    {
        _ipo = ipo;
        _tapeNumber = tapeNumber;
    }
    
    public override string ToString()
    {
        return string.Format("{0} ({1})", _ipo, _tapeNumber);
    }
}

public sealed class BallotingIPOResult
{
    public List<int> IPOs { get; private set; } 
    
    public List<IPOTape> Tapes { get; private set;  } 
    
    public List<int> NoTapes { get; private set;  }  
    
    private BallotingIPOResult() { }
    
    
    public static BallotingIPOResult Create(Dictionary<int, List<IPOTape>> dictionary)
    {
        // do the necessary checks here
        
        var ipos = dictionary.Select(s=> s.Key).ToList(); 

        var withTape = dictionary
            .Where(s=> s.Value.Count > 0)
            .SelectMany(s=> s.Value).ToList(); 

        var noTapes = dictionary.Where(s=> s.Value.Count == 0).Select(s=> s.Key)?.ToList() ?? new List<int>(0);
        
        return new BallotingIPOResult 
        {
            IPOs  = ipos,
            Tapes = withTape,
            NoTapes = noTapes
        }
    }
    
    public override string ToString()
    {
        // do the proper checks before 
        
        var builder = StringBuilder();  
        builder.Append(FormatString("Balloting IPO(s): {0}.", IPOs)); 
        builder.Append(" ");
        builder.AppendLine(FormatString("Processed Tape for Share Issue Number(s): {0}.", Tapes)); 
        
        if(NoTapes.Count > 0)
        {
            builder.Append(" ");
            builder.AppendLine(FormatString("No Tape found for Share Issue Number(s): {0}.", NoTapes));                     
        }
        
        return builder.ToString();
    }
    
    private static string FormatString<T>(string template, IEnumerable<T> items)
    {
        var value = !items.Any() ? string.Empty : string.Join(",", items);
        return string.Format(template, value);
    }

}

Now your code can be something like this :

if (ballotingIPOs.Count > 0)
{
    var ipoShareIssueNumber = ipoData.ipoDetails.ShareIssueNumber;

    var dictionary = new Dictionary<int, List<IPOTape>>();

    foreach (IPODetails ballotingIPO in ballotingIPOs)
    {
        var shareIssueNumber = ballotingIPO.ShareIssueNumber; 
        
        List<IPOTape> tapes = null;
        
        if(!dictionary.TryGetValue(shareIssueNumber, out var tapes))
        {
            tapes = new List<IPOTape>();
            dictionary.Add(shareIssueNumber, tapes);
        }
        
        if(ipoShareIssueNumber != null)
        {
            var tapeNumber = ipoData.ipoDetails.TapeNumber;     
            tapes.Add(new IPOTape(ipoShareIssueNumber, tapeNumber);
        }   
    }

    var resultModel = BallotingIPOResult.Create(dictionary);

    result += resultModel.ToString();

}
else
{
    result += "No Balloting IPOs to process.";
}

// This feels like it should be its own method
// Incorporate @mjwills comments
public string IpoLog {
   var result = new StringBuilder();
  //make this a condition-string
  var noIPOs = "No Balloting IPOs to process."

  // return immediately on terminating conditions
  if (ballotingIPOs.Count <= 0) return noIPOs;

  foreach (IPODetails ballotingIPO in ballotingIPOs) 
  { 
    ...

    // Don't bother to test `length`, just append a comma every time. No big deal. 
    tsBallotIPO += $"{ballotingIPO.ShareIssueNumber}, ";
  }// forEach

  // trim all substrings as needed after building them
  toBalloIPO.TrimEnd(","); 
 
  . . . 
  
  return result.ToString().TrimEnd(",");
} // IpoLog