Question

I found the following method in our code base today, and it strikes me that it might not be thread-safe. I think IEnumerable could be a reference type, and could potentially be modified by another thread while this code is executing. Is that correct, or is this method thread-safe after all? If not, is it appropriate for this method to be static? It seems like making it an instance method wouldn’t change the possibility of the entities parameter being modified in another thread.

/// <summary>
/// Writes the Entity data in <paramref name="entities"/> to a CSV file located at <paramref name="path"/>.
/// </summary>
/// <typeparam name="T">The Entity Type.</typeparam>
/// <param name="entities">A List of Type LinqEntityBase.</param>
/// <param name="path">The location of the CSV file.</param>
internal static void LinqEntitiesToCsv<T>(IEnumerable<T> entities, string path) where T : LinqEntityBase
{
    var entityBuilder = new StringBuilder();
    List<KeyValuePair<string, int>> columnInfos = GetColumnInfos<T>();
    for (int i = 0; i < columnInfos.Count; i++)
    {
        string columnName = columnInfos[i].Key;
        entityBuilder.Append(columnName.Contains(',') ? columnName.WrapIn('\"') : columnName);
        entityBuilder.Append(i < columnInfos.Count - 1 ? "," : string.Empty);
    }

    entityBuilder.Append(Environment.NewLine);

    PropertyInfo[] propertyInfos = typeof (T).GetPropertiesFromCache().ToArray();
    foreach (T entity in entities)
    {
        for (int i = 0; i < propertyInfos.Length; i++)
        {
            var columnAttribute = Attribute
                                        .GetCustomAttribute(propertyInfos[i], typeof (ColumnAttribute))
                                    as ColumnAttribute;
            if (columnAttribute == null)
            {
                continue;
            }

            object value = propertyInfos[i].GetValue(entity, null);
            string valueString = (value != null) ? value.ToString() : string.Empty;

            entityBuilder.Append(valueString.Contains(',') ? valueString.WrapIn('\"') : valueString);
            entityBuilder.Append(i < columnInfos.Count - 1 ? "," : string.Empty);
        }

        entityBuilder.Append(Environment.NewLine);
    }

    FileHelper.TryWriteTextFile(path, entityBuilder.ToString());
}

Answer 1

You are correct.

The actual safety of the method depends on what you kind of IEnumerable you pass it; thread safety rarely exists in a vacuum.
For example, all of the concurrent collections are completely thread-safe, even for concurrent writes and enumerations.