If you're a C# developer learning React, you're going to make specific mistakes that JavaScript-first developers never make. I've coached hundreds of .NET developers through this transition — here are the 5 patterns that trip up nearly everyone.

1. Treating State Like Mutable Properties

In C#, you update a property and the UI responds (especially with INotifyPropertyChanged or ObservableCollection). In React, mutating state directly does nothing.

// C# — this works
this.Count += 1;

// React — this BREAKS (no re-render)
count += 1;

// React — this works
setCount(prev => prev + 1);

The fix: Think of useState as an immutable value + a replacement function, not a mutable field.

2. Using useEffect Like a Constructor

C# developers see useEffect and think "constructor + lifecycle hooks." They throw everything in there — data fetching, subscriptions, one-time setup — all in one massive effect.

The fix: Each useEffect should do ONE thing. Think of them like separate IDisposable implementations, each with their own cleanup.

3. Over-Engineering with Class Patterns

Your instinct is to reach for inheritance, interfaces, and abstract classes. React doesn't work that way. Composition > inheritance, always.

// C# instinct — abstract base component
public abstract class BaseComponent<T> : Component { }

// React way — composition with hooks
function useSharedLogic() { /* custom hook */ }

The fix: Replace every inheritance hierarchy with a custom hook or a wrapper component.

4. Dependency Injection Overkill

In .NET, you register services in Program.cs and inject everywhere. In React, you don't need a DI container — Context API + hooks handle it, but you should use them sparingly.

The fix: Only use Context for truly global concerns (auth, theme, locale). For everything else, pass props or colocate state.

5. Ignoring the Render Cycle

C# developers often don't realize that the entire function body runs on every render. They put expensive operations at the top level without memoization.

The fix: Learn useMemo and useCallback — they're your equivalent of caching computed properties.

---

I built an entire course specifically for C# .NET developers making this transition. Every lesson maps React concepts to patterns you already know — no starting from scratch, no "what is a variable" filler.

If this resonated, the course goes much deeper. 👇