In modern software development, performance is a critical factor for the success of our applications. Especially in high-traffic systems, even micro-optimizations can have significant effects. In this article, we will examine the performance effects of different parameter passing methods in C# in detail.

Test Environment and Methodology

• **Technical Specifications
  **- Test Framework: BenchmarkDotNet
  - Test Scenarios: Parameter counts from 3 to 8
  - Total Test Count: 660 (60 scenarios × average 11 iterations)
  - Tested Types:
  — Struct Based: `struct`, `readonly struct`, `ref struct`, `readonly ref struct`, `record struct`, `readonly record struct`
  — Reference Based: `class`, `sealed class`, `record`, `sealed record`
  — Direct Parameter Passing
• **Measurement Metrics
  **- Mean: Average execution time of the method
  - Error: Error margin in measurements
  - StdDev: Consistency of measurements
  - Median: Median execution time
  - Memory Usage: Amount of memory allocated on the heap

Raw Benchmark Results

Performance of Struct-Based Types

**1. struct and readonly struct
**Structs showed the best performance especially for small data structures:
- ~0.6–0.7 ns with 3–4 parameters
- ~0.01–0.03 ns with 5+ parameters
- No memory allocation (stack-based)
- `readonly struct` is 5–10% faster on average compared to normal `struct`

**2. ref struct and readonly ref struct
**Safe performance with heap allocation restriction:
- Similar performance to normal structs
- No memory allocation
- Extra security with reference semantics

**3. record struct and readonly record struct
**High performance with modern C# features:
- Best performing structures
- ~0.57 ns with 3–4 parameters
- ~0.01–0.02 ns with 5+ parameters
- Includes immutability and equality comparison

Performance of Reference Types

**1. class and sealed class
**General characteristics of reference types:
- Average range of 3.4–4.0 ns
- `sealed class` is 1–3% faster than normal `class`

**2. record and sealed record
**Modern immutable data structures:
- Similar performance to classes
- Same memory usage pattern
- Value-based equality and immutability advantages

**Direct Parameter Passing
**The simplest approach:
- Consistent low latency (~0.015–0.037 ns)
- No memory allocation
- Code readability and maintenance difficulty disadvantages

General Recommendations

**Less Than 5 Parameters
**- Prefer `readonly record struct`
- Use `readonly ref struct` if memory sensitive
- Use `record` if immutability is important

**5+ Parameters
**- Struct-based types have significant advantage
- Use `readonly` modifier
- Consider parameter grouping

**Special Cases
**- When inheritance is needed: Base class with inheritance hierarchy
- When value equality is important: `record`
- When stack-only is required: `ref struct`

Performance Optimization Suggestions

**By Parameter Count
**- 3–4 parameters: Struct-based types
- 5+ parameters: Readonly struct variations
- Many parameters: Consider grouping

**Memory Optimization
**- Maximize stack usage
- Avoid unnecessary heap allocations
- Use appropriately sized structs

**Type Selection Criteria
**- Performance requirements
- Memory constraints
- Code maintainability balance

**Conclusion
**This benchmark study has thoroughly revealed the performance characteristics of parameter passing methods in C#. Especially modern C# features (like `readonly record struct`) offer significant advantages in terms of both performance and code quality.

**Key findings
**1. Struct-based types show superior performance especially with 5+ parameters
2. Positive performance effect of readonly modifier
3. Modern and efficient use of record structures
4. Memory usage characteristics of reference types

You can access the source code of the benchmark tests in this article via .NET Fiddle.

**About the Author
**- Website: senrecep.com
- GitHub: senrecep
- Nuget: recepsen
- LinkedIn: senrecep
- X: @senrecep0