less allocations

src/AutoMapper/ApiCompatBaseline.txt

@@ -8,7 +8,7 @@ MembersMustExist : Member 'public void AutoMapper.IMappingExpressionBase<TSource
 InterfacesShouldHaveSameMembers : Interface member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression' is present in the contract but not in the implementation.
 InterfacesShouldHaveSameMembers : Interface member 'public System.String AutoMapper.INamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.String AutoMapper.INamingConvention.ReplaceValue(System.Text.RegularExpressions.Match)' does not exist in the implementation but it does exist in the contract.
-InterfacesShouldHaveSameMembers : Interface member 'public System.String[] AutoMapper.INamingConvention.Split(System.String)' is present in the implementation but not in the contract.
+InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.List<System.ReadOnlyMemory<System.Char>> AutoMapper.INamingConvention.Split(System.String)' is present in the implementation but not in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression.get()' is present in the contract but not in the implementation.
 MembersMustExist : Member 'public System.Text.RegularExpressions.Regex AutoMapper.INamingConvention.SplittingExpression.get()' does not exist in the implementation but it does exist in the contract.
 InterfacesShouldHaveSameMembers : Interface member 'public System.Collections.Generic.IReadOnlyCollection<AutoMapper.Configuration.TypeMapConfiguration> AutoMapper.IProfileConfiguration.OpenTypeMapConfigs.get()' is present in the implementation but not in the contract.

src/AutoMapper/Configuration/Conventions/MemberConfiguration.cs

@@ -3,6 +3,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 namespace AutoMapper.Configuration.Conventions
@@ -82,30 +83,61 @@ public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourc
         {
             var destinationMemberNamingConvention = isReverseMap ? SourceMemberNamingConvention : DestinationMemberNamingConvention;
             var matches = destinationMemberNamingConvention.Split(nameToSearch);
-            var length = matches.Length;
-            if (length < 2)
+            if (matches == null)
             {
                 return false;
             }
             var sourceMemberNamingConvention = isReverseMap ? DestinationMemberNamingConvention : SourceMemberNamingConvention;
             var separator = sourceMemberNamingConvention.SeparatorCharacter;
-            for (var index = 1; index <= length; index++)
+            var length = matches.Count - 1;
+            for (var index = 0; index <= length; index++)
             {
-                var first = string.Join(separator, matches, 0, index);
+                var first = Join(separator, matches, 0, index);
                 var matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, first);
-                if (matchingMemberInfo != null)
+                if (matchingMemberInfo == null)
                 {
-                    resolvers.Add(matchingMemberInfo);
-                    var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
-                    var second = string.Join(separator, matches, index, length - index);
-                    if (parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, second, resolvers, isReverseMap))
-                    {
-                        return true;
-                    }
-                    resolvers.RemoveAt(resolvers.Count - 1);
+                    continue;
+                }
+                resolvers.Add(matchingMemberInfo);
+                if (index == length)
+                {
+                    return true;
+                }
+                var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
+                var second = Join(separator, matches, index + 1, length);
+                if (parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, second, resolvers, isReverseMap))
+                {
+                    return true;
                 }
+                resolvers.RemoveAt(resolvers.Count - 1);
             }
             return false;
+            static string Join(string separator, List<ReadOnlyMemory<char>> matches, int startIndex, int endIndex)
+            {
+                Debug.Assert(startIndex <= endIndex);
+                int resultLength = 0;
+                var separatorLength = separator.Length;
+                for (int index = startIndex; index <= endIndex; index++)
+                {
+                    resultLength += matches[index].Length + separatorLength;
+                }
+                resultLength -= separatorLength;
+                return string.Create(resultLength, (matches, startIndex, endIndex, separator), static (span, state) =>
+                {
+                    var separatorSpan = state.separator.AsSpan();
+                    for (int index = state.startIndex, destinationIndex = 0; index <= state.endIndex; index++)
+                    {
+                        var match = state.matches[index].Span;
+                        match.CopyTo(span[destinationIndex..]);
+                        destinationIndex += match.Length;
+                        if (index != state.endIndex)
+                        {
+                            separatorSpan.CopyTo(span[destinationIndex..]);
+                            destinationIndex += separatorSpan.Length;
+                        }
+                    }
+                });
+            }
         }
     }
 }

src/AutoMapper/Configuration/INamingConvention.cs

@@ -2,49 +2,50 @@
 using System.Collections.Generic;
 namespace AutoMapper
 {
+    using StringChars = ReadOnlyMemory<char>;
     /// <summary>
     /// Defines a naming convention strategy
     /// </summary>
     public interface INamingConvention
     {
-        string[] Split(string input);
+        List<StringChars> Split(string input);
         string SeparatorCharacter { get; }
     }
     public class ExactMatchNamingConvention : INamingConvention
     {
         public static readonly ExactMatchNamingConvention Instance = new();
-        public string[] Split(string _) => Array.Empty<string>();
+        public List<StringChars> Split(string _) => null;
         public string SeparatorCharacter => null;
     }
     public class PascalCaseNamingConvention : INamingConvention
     {
         public static readonly PascalCaseNamingConvention Instance = new();
         public string SeparatorCharacter => "";
-        public string[] Split(string input)
+        public List<StringChars> Split(string input)
         {
-            List<string> result = null;
+            List<StringChars> result = null;
             int lower = 0;
             for(int index = 1; index < input.Length; index++)
             {
                 if (char.IsUpper(input[index]))
                 {
                     result ??= new();
-                    result.Add(input[lower..index]);
+                    result.Add(input.AsMemory(lower, index - lower));
                     lower = index;
                 }
             }
             if (result == null)
             {
-                return Array.Empty<string>();
+                return null;
             }
-            result.Add(input[lower..]);
-            return result.ToArray();
+            result.Add(input.AsMemory(lower));
+            return result;
         }
     }
     public class LowerUnderscoreNamingConvention : INamingConvention
     {
         public static readonly LowerUnderscoreNamingConvention Instance = new();
         public string SeparatorCharacter => "_";
-        public string[] Split(string input) => input.Split('_', StringSplitOptions.RemoveEmptyEntries);
+        public List<StringChars> Split(string input) => new(Array.ConvertAll(input.Split('_', StringSplitOptions.RemoveEmptyEntries), MemoryExtensions.AsMemory));
     }
 }

src/UnitTests/Internal/TypeMapFactorySpecs.cs

@@ -8,26 +8,13 @@ namespace AutoMapper.UnitTests.Tests
 {
     using AutoMapper.Internal;
     using System;
+    using System.Collections.Generic;
 
     public class StubNamingConvention : INamingConvention
     {
-        private readonly Func<Match, string> _replaceFunc;
-
-        public StubNamingConvention(Func<Match, string> replaceFunc)
-        {
-            _replaceFunc = replaceFunc;
-            SeparatorCharacter = "";
-        }
-
         public Regex SplittingExpression { get; set; }
         public string SeparatorCharacter { get; set; }
-
-        public string[] Split(string input) => SplittingExpression.Matches(input).Select(m=>m.Value).ToArray();
-
-        public string ReplaceValue(Match match)
-        {
-            return _replaceFunc(match);
-        }
+        public List<ReadOnlyMemory<char>> Split(string input) => SplittingExpression.Matches(input).Select(m => m.Value.AsMemory()).ToList();
     }
 
     public class When_constructing_type_maps_with_matching_property_names : SpecBase
@@ -69,7 +56,7 @@ public class When_using_a_custom_source_naming_convention : SpecBase
     {
         private TypeMap _map;
         private ProfileMap _mappingOptions;
-        
+
         private class Source
         {
             public SubSource some__source { get; set; }
@@ -91,7 +78,7 @@ private class TestProfile : Profile
         }
         protected override void Establish_context()
         {
-            var namingConvention = new StubNamingConvention(s => s.Value.ToLower()){SeparatorCharacter = "__", SplittingExpression = new Regex(@"[\p{Ll}\p{Lu}0-9]+(?=__?)")};
+            var namingConvention = new StubNamingConvention{ SeparatorCharacter = "__", SplittingExpression = new Regex(@"[\p{Ll}\p{Lu}0-9]+(?=__?)") };
 
             var profile = new TestProfile();
             profile.Internal().AddMemberConfiguration().AddMember<NameSplitMember>(_ =>
@@ -141,7 +128,7 @@ private class TestProfile : Profile
 
         protected override void Establish_context()
         {
-            var namingConvention = new StubNamingConvention(s => s.Value.ToLower()) { SeparatorCharacter = "__", SplittingExpression = new Regex(@"[\p{Ll}\p{Lu}0-9]+(?=__?)") };
+            var namingConvention = new StubNamingConvention{ SeparatorCharacter = "__", SplittingExpression = new Regex(@"[\p{Ll}\p{Lu}0-9]+(?=__?)") };
 
             var profile = new TestProfile();
             profile.Internal().AddMemberConfiguration().AddMember<NameSplitMember>(_ =>
@@ -192,7 +179,7 @@ public void Should_map_properties_with_different_names()
             });
 
             var mapper = config.CreateMapper();
-            var dest = mapper.Map<Destination>(new Source {Ävíator = 3, SubAirlinaFlight = 4, Value = 5});
+            var dest = mapper.Map<Destination>(new Source { Ävíator = 3, SubAirlinaFlight = 4, Value = 5 });
             dest.Aviator.ShouldBe(3);
             dest.SubAirlineFlight.ShouldBe(4);
             dest.Value.ShouldBe(5);

src/UnitTests/ReverseMapping.cs

@@ -3,8 +3,8 @@
 using System.Linq;
 using System;
 using System.Text.RegularExpressions;
-using System.Reflection;
 using AutoMapper.Internal;
+using System.Collections.Generic;
 
 namespace AutoMapper.UnitTests
 {
@@ -18,7 +18,7 @@ class Destination
         {
             public Guid Id { get; set; }
         }
-        protected override MapperConfiguration CreateConfiguration() => new(c=>
+        protected override MapperConfiguration CreateConfiguration() => new(c =>
             c.CreateMap<Destination, Source>().ForMember(src => src.Id, opt => opt.MapFrom(_ => Guid.Empty)).ReverseMap());
         [Fact]
         public void Validate() => AssertConfigurationIsValid();
@@ -45,7 +45,7 @@ public class Three2
         {
         }
 
-        protected override MapperConfiguration CreateConfiguration() => new(cfg=>
+        protected override MapperConfiguration CreateConfiguration() => new(cfg =>
         {
             cfg.CreateMap<One, Two>()
                 .ForMember(d => d.Name, o => o.MapFrom(s => "name"))
@@ -118,7 +118,7 @@ class OrderDto
             public int OrderItemsCount { get; set; }
         }
 
-        protected override MapperConfiguration CreateConfiguration() => new(c=>
+        protected override MapperConfiguration CreateConfiguration() => new(c =>
         {
             c.CreateMap<Order, OrderDto>().ReverseMap();
         });
@@ -165,10 +165,12 @@ public class OrderDto
         [Fact]
         public void Should_flatten()
         {
-            var model = new Order {
-                CustomerHolder = new CustomerHolder {
-                        Customer = new Customer { Name = "George Costanza", Total = 74.85m }
-                    }
+            var model = new Order
+            {
+                CustomerHolder = new CustomerHolder
+                {
+                    Customer = new Customer { Name = "George Costanza", Total = 74.85m }
+                }
             };
             var dto = Mapper.Map<OrderDto>(model);
             dto.CustomerName.ShouldBe("George Costanza");
@@ -306,8 +308,8 @@ public class OrderDto
         {
             cfg.CreateMap<Order, OrderDto>()
                 .ReverseMap()
-                .ForMember(d=>d.Customerholder, o=>o.Ignore())
-                .ForPath(d=>d.Customerholder.Customer.Total, o=>o.MapFrom(s=>s.CustomerholderCustomerTotal));
+                .ForMember(d => d.Customerholder, o => o.Ignore())
+                .ForPath(d => d.Customerholder.Customer.Total, o => o.MapFrom(s => s.CustomerholderCustomerTotal));
         });
 
         [Fact]
@@ -384,7 +386,7 @@ public class UnderscoreNamingConvention : INamingConvention
             public Regex SplittingExpression { get; } = new Regex(@"\p{Lu}[a-z0-9]*(?=_?)");
 
             public string SeparatorCharacter => "_";
-            public string[] Split(string input) => SplittingExpression.Matches(input).Select(m => m.Value).ToArray();
+            public List<ReadOnlyMemory<char>> Split(string input) => SplittingExpression.Matches(input).Select(m => m.Value.AsMemory()).ToList();
         }
 
         protected override MapperConfiguration CreateConfiguration() => new(cfg =>