@@ -326,7 +326,6 @@ Intra-class call binding across five languages, new language-structure coverage,
 
 ## 0.9.61 (2026-09-12)
 
-- Fix: a C# member access on a typed receiver (`db.Users` in `db.Users.Where(...)`, `this.Count`, `Config.Instance`) now resolves to the receiver type's property node as a `uses` edge, the way `recv.Method()` resolves to its method — so the ORM query sites behind a `DbSet<T>` property, whose table name never appears in source, are reachable from the property (#3528).
 - Fix: `graphify.serve` now imports cleanly on Python 3.12 and 3.13. The `chinese` extra pins `jieba-py` from 3.12 onward (0.9.60 mistakenly kept the old `jieba` until 3.14, and its invalid regex escapes are a hard error on 3.12+), and the jieba import now suppresses the tokenizer's `SyntaxWarning` regardless of message or line so it never escalates under `-W error`.
 - Fix: the git hook's rebuild-root guard now rejects a symlink-loop or dangling `.graphify_root` on Python 3.13, whose `Path.resolve()` no longer raises on a loop — the saved root must resolve to a real directory inside the repo before it is adopted.
 
 
@@ -4859,35 +4859,31 @@ def _key(label: str) -> str:
     resolver = CsharpNameResolver(all_nodes, all_edges)
 
     # (type_node_id, method_key) -> method_node_id, and caller -> enclosing type.
-    # C# owns its methods via `method` edges.
+    # C# owns its methods via `method` edges. property_index is the member-
+    # access twin (#3528): (type_node_id, property_key) -> property_node_id. A
+    # C# property is the target of a `defines` edge from its type (#3006); C++
+    # data members ride the same relation, so keep to targets declared in a
+    # .cs file — a receiver typed by bare-name fallback must not reach a
+    # same-named C++ member. One pass over the edges fills both.
     method_index: dict[tuple[str, str], str] = {}
+    property_index: dict[tuple[str, str], str] = {}
     enclosing_type: dict[str, str] = {}
     for e in all_edges:
-        if e.get("relation") != "method":
+        rel = e.get("relation")
+        if rel != "method" and rel != "defines":
             continue
         src, tgt = e.get("source"), e.get("target")
         tnode = node_by_id.get(tgt)
         if tnode is None:
             continue
-        enclosing_type.setdefault(tgt, src)
-        method_index[(src, _key(tnode.get("label", "")))] = tgt
-
-    # (type_node_id, property_key) -> property_node_id, the member-access twin
-    # of method_index (#3528). A C# property is the target of a `defines` edge
-    # from its type (#3006); C++ data members ride the same relation, so keep
-    # to targets declared in a .cs file — a receiver typed by bare-name
-    # fallback must not reach a same-named C++ member.
-    property_index: dict[tuple[str, str], str] = {}
-    for e in all_edges:
-        if e.get("relation") != "defines":
-            continue
-        src, tgt = e.get("source"), e.get("target")
-        if not (isinstance(src, str) and isinstance(tgt, str)):
-            continue
-        tnode = node_by_id.get(tgt)
-        if tnode is None or not str(tnode.get("source_file", "")).endswith(".cs"):
-            continue
-        property_index[(src, _key(tnode.get("label", "")))] = tgt
+        if rel == "method":
+            enclosing_type.setdefault(tgt, src)
+            method_index[(src, _key(tnode.get("label", "")))] = tgt
+        elif (
+            isinstance(src, str) and isinstance(tgt, str)
+            and str(tnode.get("source_file", "")).endswith(".cs")
+        ):
+            property_index[(src, _key(tnode.get("label", "")))] = tgt
 
     # Base-class chain from `inherits` edges (C# files only). The type-reference
     # pass has already re-pointed each resolvable base to its real definition and
@@ -4941,6 +4937,13 @@ def _member_on_type_or_bases(
             frontier.extend(bases_of.get(nid, []))
         return next(iter(hits)) if len(hits) == 1 else None
 
+    # (type_name, caller_nid, src_file) -> resolved type nid, or None. A
+    # method reads and calls the same receiver (`db`, `_context`) many times
+    # over, and every member access (#3528) is one more entry that types it,
+    # so resolve each name once per caller rather than re-walking the
+    # namespace/using scope chain for every site.
+    type_nid_memo: dict[tuple[str, str | None, str], str | None] = {}
+
     def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
                                src_file: str) -> str | None:
         """Resolve a declared type name to exactly one definition node id.
@@ -4953,16 +4956,24 @@ def _resolve_type_name_nid(type_name: str | None, caller_node: dict | None,
         """
         if not type_name:
             return None
+        memo_key = (
+            type_name,
+            caller_node.get("id") if caller_node is not None else None,
+            src_file,
+        )
+        if memo_key in type_nid_memo:
+            return type_nid_memo[memo_key]
+        type_nid: str | None = None
+        decisive = False
         if caller_node is not None:
-            resolved, decisive = resolver.resolve_type_name(
+            type_nid, decisive = resolver.resolve_type_name(
                 type_name, caller_node, src_file
             )
-            if resolved:
-                return resolved
-            if decisive:
-                return None
-        type_defs = type_def_nids.get(_key(type_name), [])
-        return type_defs[0] if len(type_defs) == 1 else None
+        if not type_nid and not decisive:
+            type_defs = type_def_nids.get(_key(type_name), [])
+            type_nid = type_defs[0] if len(type_defs) == 1 else None
+        type_nid_memo[memo_key] = type_nid
+        return type_nid
 
     def _park_if_absent(type_name: str | None, caller_node: dict | None, rc: dict) -> None:
         """Park a call whose receiver type is declared nowhere in this corpus (#3152).
 
@@ -7183,6 +7183,12 @@ def scala_base_name(type_node) -> str | None:
     seen_static_ref_pairs: set[tuple[str, str, str]] = set()
     seen_helper_ref_pairs: set[tuple[str, str, str]] = set()
     seen_bind_pairs: set[tuple[str, str, str]] = set()
+    # C#: node ids of the member_access_expression that is an invocation's
+    # callee (`db.Users.Where` in `db.Users.Where(...)`), recorded when the
+    # invocation is visited so the member-access branch below can tell it
+    # apart from a property read (#3528) without asking tree-sitter for
+    # `node.parent`, which re-descends from the root on every call.
+    csharp_callee_ids: set[int] = set()
     raw_calls: list[dict] = []  # unresolved calls for cross-file resolution in extract()
     # Ruby: per-method `var -> ClassName` table from `var = Const.new` bindings,
     # populated before walk_calls runs. Lets member-call raw_calls carry a
@@ -7664,6 +7670,8 @@ def walk_calls(
                 member_parts = _csharp_member_call_parts(fn_node)
                 csharp_table = receiver_types if isinstance(receiver_types, tuple) else None
                 if member_parts is not None:
+                    if fn_node.type == "member_access_expression":
+                        csharp_callee_ids.add(fn_node.id)
                     mname, recv = member_parts
                     if mname is not None:
                         # `recv.Get<int>(...)`: the name field is a
@@ -8363,14 +8371,16 @@ def walk_calls(
         # member calls use, for _resolve_csharp_member_calls to bind to the
         # receiver type's property node. The callee of an invocation is its
         # `function` field, and that is the only member_access_expression
-        # ever parented directly by one (arguments sit under argument_list),
-        # so the parent check is what separates `db.Users` from
+        # ever parented directly by one (arguments sit under argument_list);
+        # the walk is pre-order, so the invocation branch above has already
+        # put that node's id in csharp_callee_ids by the time the walk reaches
+        # it, and the id check is what separates `db.Users` from
         # `db.Users.Add`. A generic_name member (`db.Set<T>`) is a call, not a
         # property, and is left to the call-site type-argument pass (#2911).
         if (
             config.ts_module == "tree_sitter_c_sharp"
             and node.type == "member_access_expression"
-            and not (node.parent is not None and node.parent.type == "invocation_expression")
+            and node.id not in csharp_callee_ids
         ):
             member_name = node.child_by_field_name("name")
             access_receiver = (
 
@@ -398,3 +398,24 @@ def test_untypable_lowercase_receiver_records_no_raw_entry(tmp_path):
     )
     entries = [rc for rc in extract_csharp(p)["raw_calls"] if rc.get("is_member_access")]
     assert entries == []
+
+
+def test_invocation_callee_is_a_call_entry_not_an_access_entry(tmp_path):
+    # `db.Save()` reaches the walk twice: once as the invocation, once as the
+    # member_access_expression that is its callee. The callee must surface
+    # only as the call — never as a second, dead access entry for `Save`.
+    # The walk is pre-order, so the invocation records the callee's node id
+    # before the access branch reaches it; nested and chained shapes must
+    # keep that straight too.
+    p = tmp_path / "S.cs"
+    p.write_text(
+        "public class Svc {\n"
+        "    private Ctx db;\n"
+        "    public void Q() { db.Save(); db.Log(db.Users); db.Users.Add(db.Orders.First()); }\n"
+        "}\n"
+    )
+    raw = [rc for rc in extract_csharp(p)["raw_calls"] if rc.get("lang") == "csharp"]
+    accesses = sorted(rc["callee"] for rc in raw if rc.get("is_member_access"))
+    calls = sorted(rc["callee"] for rc in raw if not rc.get("is_member_access"))
+    assert accesses == ["Orders", "Users", "Users"]
+    assert calls == ["Add", "First", "Log", "Save"]