【C#】Trimで文字列の前後空白を削除する基本と応用テクニック

using System;
class Program
{
    static void Main()
    {
        string original = "  \t こんにちは、世界！\n  ";
        // 先頭と末尾の空白文字を取り除く
        string trimmed = original.Trim();
        Console.WriteLine($"元の文字列: '{original}'");
        Console.WriteLine($"Trim()後の文字列: '{trimmed}'");
    }
}

元の文字列: '  	  こんにちは、世界！
  '
Trim()後の文字列: 'こんにちは、世界！'

using System;
class Program
{
    static void Main()
    {
        string mixedSpaces = "\u3000\tこんにちは、世界！\n\u3000";
        // 先頭と末尾の空白文字を取り除く
        string trimmed = mixedSpaces.Trim();
        Console.WriteLine($"元の文字列: '{mixedSpaces}'");
        Console.WriteLine($"Trim()後の文字列: '{trimmed}'");
    }
}

元の文字列: '　 	こんにちは、世界！
　'
Trim()後の文字列: 'こんにちは、世界！'

using System;
class Program
{
    static void Main()
    {
        string input = "  \t 先頭に空白があります。  ";
        // 先頭の空白文字を削除
        string trimmedStart = input.TrimStart();
        Console.WriteLine($"元の文字列: '{input}'");
        Console.WriteLine($"TrimStart()後の文字列: '{trimmedStart}'");
    }
}

元の文字列: '  	  先頭に空白があります。  '
TrimStart()後の文字列: '先頭に空白があります。  '

using System;
class Program
{
    static void Main()
    {
        string input = "  末尾に空白があります。  \n\t";
        // 末尾の空白文字を削除
        string trimmedEnd = input.TrimEnd();
        Console.WriteLine($"元の文字列: '{input}'");
        Console.WriteLine($"TrimEnd()後の文字列: '{trimmedEnd}'");
    }
}

元の文字列: '  末尾に空白があります。
'
TrimEnd()後の文字列: '  末尾に空白があります。'

using System;
class Program
{
    static void Main()
    {
        string original = "***,こんにちは、世界！,***";
        char[] trimChars = { '*', ',' };
        // 前後のアスタリスクとカンマを削除
        string trimmed = original.Trim(trimChars);
        Console.WriteLine($"元の文字列: '{original}'");
        Console.WriteLine($"Trim('*', ',')後の文字列: '{trimmed}'");
    }
}

元の文字列: '***,こんにちは、世界！,***'
Trim('*', ',')後の文字列: 'こんにちは、世界！'

using System;
class Program
{
    static void Main()
    {
        string original = "***,こんにちは、世界！,***";
        char[] trimChars = { '*', ',' };
        // 先頭のアスタリスクとカンマを削除
        string trimmedStart = original.TrimStart(trimChars);
        // 末尾のアスタリスクとカンマを削除
        string trimmedEnd = original.TrimEnd(trimChars);
        Console.WriteLine($"TrimStart('*', ',')後: '{trimmedStart}'");
        Console.WriteLine($"TrimEnd('*', ',')後: '{trimmedEnd}'");
    }
}

TrimStart('*', ',')後: 'こんにちは、世界！,***'
TrimEnd('*', ',')後: '***,こんにちは、世界！'

using System;
class Program
{
    static void Main()
    {
        string original = "\u3000\u3000こんにちは、世界！\u3000\u3000";
        char[] trimChars = { '\u3000' }; // 全角スペース
        // 全角スペースを前後から削除
        string trimmed = original.Trim(trimChars);
        Console.WriteLine($"元の文字列: '{original}'");
        Console.WriteLine($"全角スペースTrim後: '{trimmed}'");
    }
}

元の文字列: '　　 こんにちは、世界！　　 '
全角スペースTrim後: 'こんにちは、世界！'

using System;
class Program
{
    static void Main()
    {
        string original = "こんにちは、世界！";
        char[] trimChars = { '' };
        // 絵文字のハートを前後から削除
        string trimmed = original.Trim(trimChars);
        Console.WriteLine($"元の文字列: '{original}'");
        Console.WriteLine($"絵文字Trim後: '{trimmed}'");
    }
}

元の文字列: 'こんにちは、世界！'
絵文字Trim後: 'こんにちは、世界！'

using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        const int count = 1_000_000;
        string[] data = new string[count];
        for (int i = 0; i < count; i++)
        {
            data[i] = "  データ " + i + "  \t\n";
        }
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < count; i++)
        {
            data[i] = data[i].Trim();
        }
        sw.Stop();
        Console.WriteLine($"100万件のTrim処理にかかった時間: {sw.ElapsedMilliseconds} ms");
    }
}

100万件のTrim処理にかかった時間: 56 ms

using System;
using System.Buffers;
class Program
{
    static void Main()
    {
        string original = "  \t Trim対象の文字列 \n  ";
        // Span<char>で文字列を参照
        ReadOnlySpan<char> span = original.AsSpan();
        // 先頭の空白をスキップ
        int start = 0;
        while (start < span.Length && char.IsWhiteSpace(span[start]))
        {
            start++;
        }
        // 末尾の空白をスキップ
        int end = span.Length - 1;
        while (end >= start && char.IsWhiteSpace(span[end]))
        {
            end--;
        }
        int length = end - start + 1;
        // MemoryPoolからバッファを借りてコピー
        using var buffer = MemoryPool<char>.Shared.Rent(length);
        span.Slice(start, length).CopyTo(buffer.Memory.Span);
        string trimmed = new string(buffer.Memory.Span.Slice(0, length));
        Console.WriteLine($"元の文字列: '{original}'");
        Console.WriteLine($"SpanとMemoryPoolでTrim相当処理後: '{trimmed}'");
    }
}

元の文字列: '  	  Trim対象の文字列
  '
SpanとMemoryPoolでTrim相当処理後: 'Trim対象の文字列'

using System;
class Program
{
    static void Main()
    {
        string? nullableString = null;
        // nullの場合は空文字列に置き換えてからTrimを実行
        string trimmed = (nullableString ?? "").Trim();
        Console.WriteLine($"元の文字列: {(nullableString == null ? "null" : $"'{nullableString}'")}");
        Console.WriteLine($"Trim後の文字列: '{trimmed}'");
    }
}

元の文字列: null
Trim後の文字列: ''

using System;
class Person
{
    private string _name = "";
    public string Name
    {
        get => _name;
        set => _name = value.Trim(); // nullが入ると例外になる
    }
}
class Program
{
    static void Main()
    {
        Person person = new Person();
        try
        {
            person.Name = null!; // nullを代入(null許容型でないため警告あり)
        }
        catch (Exception ex)
        {
            Console.WriteLine($"例外発生: {ex.GetType().Name} - {ex.Message}");
        }
    }
}

例外発生: NullReferenceException - Object reference not set to an instance of an object.

using System;
class Person
{
    private string _name = "";
    public string Name
    {
        get => _name;
        set => _name = (value ?? "").Trim();
    }
}
class Program
{
    static void Main()
    {
        Person person = new Person();
        person.Name = null; // nullを代入しても例外にならない
        Console.WriteLine($"Name: '{person.Name}'"); // 空文字列になる
    }
}

Name: ''

using System;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        string input = "  \t こんにちは、世界！\n  ";
        // 先頭と末尾の空白を正規表現で削除
        string pattern = @"^\s+|\s+$";
        string replaced = Regex.Replace(input, pattern, "");
        Console.WriteLine($"元の文字列: '{input}'");
        Console.WriteLine($"Regex.Replace後: '{replaced}'");
    }
}

元の文字列: '  	  こんにちは、世界！
  '
Regex.Replace後: 'こんにちは、世界！'

using System;
using System.Diagnostics;
using System.Text.RegularExpressions;
class Program
{
    static void Main()
    {
        const int count = 1_000_000;
        string input = "  テスト文字列  ";
        Stopwatch sw = Stopwatch.StartNew();
        for (int i = 0; i < count; i++)
        {
            string trimmed = input.Trim();
        }
        sw.Stop();
        Console.WriteLine($"Trim() 100万回: {sw.ElapsedMilliseconds} ms");
        sw.Restart();
        string pattern = @"^\s+|\s+$";
        for (int i = 0; i < count; i++)
        {
            string replaced = Regex.Replace(input, pattern, "");
        }
        sw.Stop();
        Console.WriteLine($"Regex.Replace 100万回: {sw.ElapsedMilliseconds} ms");
    }
}

Trim() 100万回: 21 ms
Regex.Replace 100万回: 452 ms

using System;
class Program
{
    static void Main()
    {
        string name = "太郎";
        string message = $"こんにちは、{name}さん！\n" +
                         $"今日はいい天気ですね。  ";
        Console.WriteLine($"メッセージ: '{message}'");
        Console.WriteLine($"Trim後: '{message.Trim()}'");
    }
}

メッセージ: 'こんにちは、太郎さん！
今日はいい天気ですね。  '
Trim後: 'こんにちは、太郎さん！
今日はいい天気ですね。'

using System;
class Program
{
    static void Main()
    {
        string name = "花子";
        string message = $@"
こんにちは、{name}さん！
今日はいい天気ですね。
";
        Console.WriteLine($"メッセージ: '{message}'");
        Console.WriteLine($"Trim後: '{message.Trim()}'");
    }
}

メッセージ: '
こんにちは、花子さん！
今日はいい天気ですね。
'
Trim後: 'こんにちは、花子さん！
今日はいい天気ですね。'

using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
    static void Main()
    {
        List<string> names = new List<string>
        {
            "  Alice  ",
            "\tBob",
            "Charlie\n",
            "  David  "
        };
        // 各要素の前後の空白をTrimで削除
        IEnumerable<string> trimmedNames = names.Select(name => name.Trim());
        foreach (var trimmed in trimmedNames)
        {
            Console.WriteLine($"'{trimmed}'");
        }
    }
}

'Alice'
'Bob'
'Charlie'
'David'

var trimmedNames = names.Select(name => name.Trim());

var trimmedNames =
    from name in names
    select name.Trim();

var filteredTrimmedNames =
    from name in names
    where !string.IsNullOrWhiteSpace(name)
    select name.Trim();

using System;
public static class StringExtensions
{
    public static string SafeTrim(this string? source)
    {
        return source?.Trim() ?? string.Empty;
    }
}
class Program
{
    static void Main()
    {
        string? nullableString = null;
        string? normalString = "  Hello World!  ";
        Console.WriteLine($"null文字列のTrim: '{nullableString.SafeTrim()}'");
        Console.WriteLine($"通常文字列のTrim: '{normalString.SafeTrim()}'");
    }
}

null文字列のTrim: ''
通常文字列のTrim: 'Hello World!'

using System;
using System.Collections.Generic;
using System.Linq;
public static class EnumerableExtensions
{
    public static IEnumerable<T> TrimEdges<T>(this IEnumerable<T> source, params T[] trimValues)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (trimValues == null) throw new ArgumentNullException(nameof(trimValues));
        var list = source.ToList();
        int start = 0;
        int end = list.Count - 1;
        // 先頭からtrimValuesに含まれる要素をスキップ
        while (start <= end && trimValues.Contains(list[start]))
        {
            start++;
        }
        // 末尾からtrimValuesに含まれる要素をスキップ
        while (end >= start && trimValues.Contains(list[end]))
        {
            end--;
        }
        for (int i = start; i <= end; i++)
        {
            yield return list[i];
        }
    }
}
class Program
{
    static void Main()
    {
        var numbers = new List<int> { 0, 0, 1, 2, 3, 0, 0 };
        var trimmedNumbers = numbers.TrimEdges(0);
        Console.WriteLine("元のリスト: " + string.Join(", ", numbers));
        Console.WriteLine("TrimEdges後: " + string.Join(", ", trimmedNumbers));
    }
}

元のリスト: 0, 0, 1, 2, 3, 0, 0
TrimEdges後: 1, 2, 3

using System;
class Program
{
    static void Main()
    {
        string str = "\u200BHello World\u200B";
        Console.WriteLine($"元の文字列の長さ: {str.Length}");
        string trimmed = str.Trim();
        Console.WriteLine($"Trim後の文字列の長さ: {trimmed.Length}");
        Console.WriteLine($"Trim後の文字列: '{trimmed}'");
    }
}

元の文字列の長さ: 13
Trim後の文字列の長さ: 13
Trim後の文字列: '​Hello World​'

using System;
class Program
{
    static void Main()
    {
        // ユーザーが入力した文字列(例として直接代入)
        string userInput = "  example input  ";
        // 入力値の前後空白を削除
        string trimmedInput = userInput.Trim();
        // バリデーション処理(例：空文字チェック)
        if (string.IsNullOrEmpty(trimmedInput))
        {
            Console.WriteLine("入力が空です。");
        }
        else
        {
            Console.WriteLine($"入力値: '{trimmedInput}'");
        }
    }
}

入力値: 'example input'

using Microsoft.AspNetCore.Mvc.ModelBinding;
using System;
using System.Threading.Tasks;
public class TrimStringModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null) throw new ArgumentNullException(nameof(bindingContext));
        var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (valueProviderResult == ValueProviderResult.None)
        {
            return Task.CompletedTask;
        }
        bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
        string value = valueProviderResult.FirstValue;
        if (value == null)
        {
            bindingContext.Result = ModelBindingResult.Success(null);
            return Task.CompletedTask;
        }
        // 文字列の前後空白を削除
        string trimmedValue = value.Trim();
        bindingContext.Result = ModelBindingResult.Success(trimmedValue);
        return Task.CompletedTask;
    }
}

services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new TrimStringModelBinderProvider());
});

using System;
using System.IO;
class Program
{
    static void Main()
    {
        string filePath = "sample.csv";
        // CSVファイルの例
        // "  Alice  , 25 , Engineer "
        // " Bob , 30 , Designer "
        using (var reader = new StreamReader(filePath))
        {
            string? line;
            while ((line = reader.ReadLine()) != null)
            {
                // カンマで分割
                string[] cells = line.Split(',');
                // 各セルの前後空白をTrim
                for (int i = 0; i < cells.Length; i++)
                {
                    cells[i] = cells[i].Trim();
                }
                // トリム後のセルを表示
                Console.WriteLine(string.Join(" | ", cells));
            }
        }
    }
}

Alice | 25 | Engineer
Bob | 30 | Designer

using System;
using System.IO;
class Program
{
    static void Main()
    {
        string filePath = "data.txt";
        using (var reader = new StreamReader(filePath))
        {
            string? line;
            while ((line = reader.ReadLine()) != null)
            {
                // 行の前後空白を削除
                string trimmedLine = line.Trim();
                if (string.IsNullOrEmpty(trimmedLine))
                {
                    // 空行はスキップ
                    continue;
                }
                // トリム済みの行を処理
                Console.WriteLine(trimmedLine);
            }
        }
    }
}

(ファイル内の空白や改行が除去された行が表示される)

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
public class TrimStringConverter : JsonConverter<string>
{
    public override string? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        string? value = reader.GetString();
        return value?.Trim();
    }
    public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options)
    {
        writer.WriteStringValue(value);
    }
}
class Program
{
    public class Person
    {
        public string Name { get; set; } = string.Empty;
    }
    static void Main()
    {
        string json = @"{ ""Name"": ""  太郎  "" }";
        var options = new JsonSerializerOptions();
        options.Converters.Add(new TrimStringConverter());
        Person person = JsonSerializer.Deserialize<Person>(json, options)!;
        Console.WriteLine($"Name: '{person.Name}'"); // 前後の空白が削除されている
    }
}

Name: '太郎'

using System;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System.Reflection;
public class TrimStringContractResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        if (property.PropertyType == typeof(string))
        {
            var existingSetter = property.ValueProvider;
            property.ValueProvider = new TrimStringValueProvider(existingSetter);
        }
        return property;
    }
    private class TrimStringValueProvider : IValueProvider
    {
        private readonly IValueProvider _innerProvider;
        public TrimStringValueProvider(IValueProvider innerProvider)
        {
            _innerProvider = innerProvider;
        }
        public object? GetValue(object target)
        {
            return _innerProvider.GetValue(target);
        }
        public void SetValue(object target, object? value)
        {
            if (value is string s)
            {
                s = s.Trim();
                _innerProvider.SetValue(target, s);
            }
            else
            {
                _innerProvider.SetValue(target, value);
            }
        }
    }
}
class Program
{
    public class Person
    {
        public string Name { get; set; } = string.Empty;
    }
    static void Main()
    {
        string json = @"{ ""Name"": ""  花子  "" }";
        var settings = new JsonSerializerSettings
        {
            ContractResolver = new TrimStringContractResolver()
        };
        Person person = JsonConvert.DeserializeObject<Person>(json, settings)!;
        Console.WriteLine($"Name: '{person.Name}'"); // 前後の空白が削除されている
    }
}

Name: '花子'