A few ways Exports could be improved

[jpageacsys]

I've got a few issues with the build in Export To CSV function that could be improved:

1. If a cell contains a comma such as a description column, the string is not properly formatted for CSV and creates a new column. This could be avoided: https://stackoverflow.com/questions/4617935/is-there-a-way-to-include-commas-in-csv-columns-without-breaking-the-formatting
2. There is an event for ExportAllContent which can be used to override the behavior or show a notification, but there isn't an event for when it's done. If the export takes a couple minutes, a lot of times users will open the file before it's done exporting and say it's empty but they don't have a notification to know when its safe to open. Adding an event for when it's done would allow for showing some custom notification.
3. The GetAllContent function runs on the UI thread so it appears that the app is frozen if it takes more than a second.

I implemented my own override, but I'm not able to handle commas in the strings or get the GetAllContent to run in the background thread.

    private async void ProjectTable_ExportAllContent(object sender, TableViewExportContentEventArgs e)
    {
        Debug.WriteLine("Exporting all content");
        e.Handled = true; // Mark the event as handled to prevent default export behavior so we can do our custom export that lets the user know it's progress so they don't open too soon

        try
        {
            if (await GetStorageFile() is not { } file)
            {
                return;
            }

            ToastHelper.ShowToast("Exporting Projects", "This may take a few moments.");
            // Small delay to let the toast show before getting content since that blocks the UI thread
            await Task.Delay(500);

            var content = ProjectTable.GetAllContent(true, ',');
            using var stream = await file.OpenStreamForWriteAsync();
            stream.SetLength(0);

            using var tw = new StreamWriter(stream);
            await tw.WriteAsync(content);

            ToastHelper.ClearToasts();
            var completeInfo = new ToastInfo()
            {
                Title = "Export Complete",
                Message = "The file has been saved to " + file.Path,
                Type = ToastHelper.ToastType.Success,
                ConfirmButtonText = "Open",
                ShowConfirmButton = true
            };
            completeInfo.ConfirmButtonClicked += (s, e) =>
            {
                Process.Start(new ProcessStartInfo(file.Path) { UseShellExecute = true });
                return true;
            };
            ToastHelper.ShowToast(completeInfo);
        }
        catch { }
    }
    /// <summary>
    /// Gets a storage file for saving the CSV.
    /// </summary>
    private async Task<StorageFile> GetStorageFile()
    {
        var savePicker = new FileSavePicker();
        savePicker.FileTypeChoices.Add("CSV (Comma delimited)", [".csv"]);
#if WINDOWS
        var hWnd = Microsoft.UI.Win32Interop.GetWindowFromWindowId(XamlRoot.ContentIslandEnvironment.AppWindowId);
        WinRT.Interop.InitializeWithWindow.Initialize(savePicker, hWnd);
#endif

        return await savePicker.PickSaveFileAsync();
    }

[jpageacsys]

For anyone interested, I wrote a helper class. It's using some of my own functions but the main code should be universal. I was getting a lot of complaints about crashes when users tried to copy or export large sets of data on the main thread. It would be nice if this or something similar was implemented as part of the library.
It's able to mostly run in the background thread by getting the necessary column info first and then applying it to the content in the background thread.

public static class TableViewExportHelper
{
    /// <summary>
    /// Exports table content to CSV asynchronously with progress notifications.
    /// Uses the currently visible/filtered/sorted items from the TableView.
    /// </summary>
    /// <typeparam name="T">The type of items in the collection</typeparam>
    /// <param name="tableView">The TableView control to export from</param>
    /// <param name="xamlRoot">The XamlRoot for file picker initialization</param>
    /// <param name="exportingMessage">The message to show while exporting (e.g., "Exporting Projects")</param>
    /// <returns>True if export succeeded, false if cancelled or failed</returns>
    public static async Task<bool> ExportToCSVAsync<T>(
        TableView tableView,
        XamlRoot xamlRoot,
        string exportingMessage = "Exporting data")
    {
        try
        {
            var file = await GetStorageFileAsync(xamlRoot);
            if (file == null)
            {
                return false;
            }

            ToastHelper.ShowToast(exportingMessage, "This may take a few moments.");

            // Extract column metadata AND get filtered/sorted items from TableView on UI thread
            var columnInfo = ExtractColumnInfo(tableView);
            var items = GetFilteredItems<T>(tableView);

            // Build CSV off UI thread
            var content = await GenerateDelimitedContentAsync(columnInfo, items, includeHeaders: true, delimiter: ',', useQuotes: true);

            // Write to file
            using var stream = await file.OpenStreamForWriteAsync();
            stream.SetLength(0);
            using var tw = new StreamWriter(stream);
            await tw.WriteAsync(content);

            // Show completion notification
            ToastHelper.ClearToasts();
            var completeInfo = new ToastInfo()
            {
                Title = "Export Complete",
                Message = "The file has been saved to " + file.Path,
                Type = ToastHelper.ToastType.Success,
                ConfirmButtonText = "Open",
                ShowConfirmButton = true
            };
            completeInfo.ConfirmButtonClicked += (s, e) =>
            {
                Process.Start(new ProcessStartInfo(file.Path) { UseShellExecute = true });
                return true;
            };
            ToastHelper.ShowToast(completeInfo);

            return true;
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Export failed: {ex.Message}");
            return false;
        }
    }

    /// <summary>
    /// Copies table content to clipboard as TSV (tab-separated values) for easy pasting into spreadsheets.
    /// Uses the currently selected items from the TableView. If no items are selected, copies all visible items.
    /// </summary>
    /// <typeparam name="T">The type of items in the collection</typeparam>
    /// <param name="tableView">The TableView control to copy from</param>
    /// <param name="includeHeaders">Whether to include column headers</param>
    /// <returns>True if copy succeeded, false if failed</returns>
    public static async Task<bool> CopyToClipboardAsync<T>(
        TableView tableView,
        bool includeHeaders = true)
    {
        try
        {
            // Extract column metadata on UI thread
            var columnInfo = ExtractColumnInfo(tableView);

            // Get selected items if any, otherwise get all filtered items
            var items = GetSelectedItems<T>(tableView);
            if (items.Count == 0)
            {
                items = GetFilteredItems<T>(tableView);
            }

            // Build TSV off UI thread (use tabs for clipboard)
            var content = await GenerateDelimitedContentAsync(columnInfo, items, includeHeaders, delimiter: '\t', useQuotes: false);

            // Copy to clipboard on UI thread
            var dataPackage = new DataPackage();
            dataPackage.SetText(content);
            Clipboard.SetContent(dataPackage);

            return true;
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Copy to clipboard failed: {ex.Message}");
            return false;
        }
    }

    private static List<ColumnInfo> ExtractColumnInfo(TableView tableView)
    {
        return tableView.Columns
            .OfType<TableViewBoundColumn>()
            .Where(c => c.Width.Value > 0) // Only visible columns
            .Select(col => new ColumnInfo
            {
                Header = col.Header?.ToString() ?? string.Empty,
                Path = (col.Binding as Binding)?.Path.Path
            })
            .ToList();
    }

    private static List<T> GetFilteredItems<T>(TableView tableView)
    {
        // The TableView.Items property contains the filtered/sorted items from the internal CollectionView
        // ItemsSource is the raw source, but Items is the processed view
        var items = new List<T>();

        foreach (var item in tableView.Items)
        {
            if (item is T typedItem)
            {
                items.Add(typedItem);
            }
        }

        return items;
    }

    private static List<T> GetSelectedItems<T>(TableView tableView)
    {
        // The TableView.SelectedItems property contains the currently selected items
        var items = new List<T>();

        if (tableView.SelectedItems != null)
        {
            foreach (var item in tableView.SelectedItems)
            {
                if (item is T typedItem)
                {
                    items.Add(typedItem);
                }
            }
        }

        return items;
    }

    private static async Task<string> GenerateDelimitedContentAsync<T>(
        List<ColumnInfo> columnInfo,
        List<T> items,
        bool includeHeaders,
        char delimiter,
        bool useQuotes)
    {
        return await Task.Run(() =>
        {
            var sb = new System.Text.StringBuilder();

            // Headers
            if (includeHeaders)
            {
                var headers = columnInfo.Select(c =>
                    useQuotes ? $"\"{c.Header.Replace("\"", "\"\"")}\"" : c.Header);
                sb.AppendLine(string.Join(delimiter.ToString(), headers));
            }

            // Rows
            foreach (var item in items)
            {
                var values = columnInfo.Select(col =>
                {
                    var value = GetPropertyValue(item, col.Path);
                    var stringValue = value?.ToString() ?? string.Empty;
                    return useQuotes ? $"\"{stringValue.Replace("\"", "\"\"")}\"" : stringValue;
                });
                sb.AppendLine(string.Join(delimiter.ToString(), values));
            }

            return sb.ToString();
        });
    }

    private static object? GetPropertyValue(object? obj, string? propertyPath)
    {
        if (obj == null || string.IsNullOrEmpty(propertyPath)) return null;

        var properties = propertyPath.Split('.');
        object? current = obj;

        foreach (var prop in properties)
        {
            if (current == null) return null;
            var propInfo = current.GetType().GetProperty(prop);
            current = propInfo?.GetValue(current);
        }

        return current;
    }

    private static async Task<StorageFile?> GetStorageFileAsync(XamlRoot xamlRoot)
    {
        var savePicker = new FileSavePicker();
        savePicker.FileTypeChoices.Add("CSV (Comma delimited)", [".csv"]);

#if WINDOWS
        var hWnd = Microsoft.UI.Win32Interop.GetWindowFromWindowId(xamlRoot.ContentIslandEnvironment.AppWindowId);
        WinRT.Interop.InitializeWithWindow.Initialize(savePicker, hWnd);
#endif

        return await savePicker.PickSaveFileAsync();
    }

    private class ColumnInfo
    {
        public string Header { get; set; } = string.Empty;
        public string? Path { get; set; }
    }
}