{"record":{"id":"8383fd600d8d1ff3","repo":"LuckyPennySoftware/AutoMapper","slug":"unexpected-member","errorCode":null,"errorMessage":"Unexpected member.","messagePattern":"Unexpected member\\.","errorType":"exception","errorClass":"ArgumentOutOfRangeException","httpStatus":null,"severity":"error","filePath":"src/AutoMapper/Execution/ExpressionBuilder.cs","lineNumber":215,"sourceCode":"        return result;\n    }\n    public static LambdaExpression Lambda(this MemberInfo member) => new[] { member }.Lambda();\n    public static LambdaExpression Lambda(this MemberInfo[] members)\n    {\n        var source = Parameter(members[0].DeclaringType, \"source\");\n        return Expression.Lambda(members.Chain(source), source);\n    }\n    public static Expression Chain(this MemberInfo[] members, Expression target)\n    {\n        foreach (var member in members)\n        {\n            target = member switch\n            {\n                PropertyInfo property => Expression.Property(target, property),\n                MethodInfo { IsStatic: true } getter => Expression.Call(getter, target),\n                FieldInfo field => Field(target, field),\n                MethodInfo getter => Expression.Call(target, getter),\n                _ => throw new ArgumentOutOfRangeException(nameof(member), member, \"Unexpected member.\")\n            };\n        }\n        return target;\n    }\n    public static MemberInfo[] GetMembersChain(this LambdaExpression lambda) => lambda.Body.GetChain().ToMemberInfos();\n    public static MemberInfo GetMember(this LambdaExpression lambda) =>\n        (lambda?.Body is MemberExpression memberExpression && memberExpression.Expression == lambda.Parameters[0]) ? memberExpression.Member : null;\n    public static MemberInfo[] ToMemberInfos(this Stack<Member> chain)\n    {\n        var members = new MemberInfo[chain.Count];\n        int index = 0;\n        foreach (var member in chain)\n        {\n            members[index++] = member.MemberInfo;\n        }\n        return members;\n    }\n    public static Stack<Member> GetChain(this Expression expression)","sourceCodeStart":197,"sourceCodeEnd":233,"githubUrl":"https://github.com/LuckyPennySoftware/AutoMapper/blob/dfa6dd587c5854b4beee5934beb39ba6e9569b84/src/AutoMapper/Execution/ExpressionBuilder.cs#L197-L233","documentation":"Internal defensive error thrown by ExpressionBuilder.Chain when a MemberInfo in a member-access expression chain is not a PropertyInfo, FieldInfo, or MethodInfo (static or instance). The switch expression's default arm fires. This occurs during execution-plan compilation when AutoMapper walks a member chain extracted from a user lambda and encounters an unsupported member kind.","triggerScenarios":"An expression passed to MapFrom, ForPath, or a member path that contains a member type AutoMapper does not handle (e.g., an EventInfo or a TypeInfo nested in the chain). The chain is built from GetChain which recognizes MemberExpression and MethodCallExpression nodes.","commonSituations":"Rarely hit directly by end users; usually indicates an unsupported expression shape in a MapFrom lambda or a member path that resolves to an event or nested type. May also indicate a bug in a custom IObjectMapper.","solutions":["Simplify the MapFrom or ForPath expression to use only property accesses, field accesses, and method calls.","Remove any event subscriptions or non-property/field/method references from the mapping expression.","If the expression is valid and you believe AutoMapper should support it, file a bug report with a reproduction."],"exampleFix":"// before — unsupported member in chain (e.g., event access)\nCreateMap<Source, Dest>().ForMember(d => d.Value, opt => opt.MapFrom(s => s.SomeEvent));\n\n// after — use a property or method\nCreateMap<Source, Dest>().ForMember(d => d.Value, opt => opt.MapFrom(s => s.GetValue()));","handlingStrategy":"try-catch","validationCode":"// Validate that the expression body only contains supported member types before mapping\nstatic bool IsValidMemberChain(LambdaExpression lambda)\n{\n    foreach (var member in lambda.Body.GetChain().Select(m => m.MemberInfo))\n    {\n        if (member is not (PropertyInfo or FieldInfo or MethodInfo))\n            return false;\n    }\n    return true;\n}","typeGuard":null,"tryCatchPattern":"try\n{\n    var config = new MapperConfiguration(cfg => cfg.CreateMap<Source, Dest>()\n        .ForMember(d => d.Val, opt => opt.MapFrom(s => s.GetValue())));\n    config.CompileMaps(); // triggers plan building\n}\ncatch (AutoMapperMappingException ex) when (ex.InnerException is ArgumentOutOfRangeException)\n{\n    // Log and simplify the mapping expression\n    logger.LogError(ex, \"Unsupported member in expression chain. Simplify to property/field/method accesses.\");\n}","preventionTips":["Use only property accesses, field accesses, and method calls in MapFrom and ForPath expressions.","Avoid event accesses or other non-standard member types in mapping expressions.","Run AssertConfigurationIsValid or CompileMaps in tests to surface plan-building errors early."],"tags":["execution","expression-tree","internal","reflection"],"backgroundTag":null,"analyzedSha":"dfa6dd587c5854b4beee5934beb39ba6e9569b84","analyzedAt":"2026-08-13T19:56:33.518Z","schemaVersion":2},"datasetVersion":"2026-08-14T00:17:13.853Z"}