Dotnet Framework

.NET Framework Development

Build and Compilation Requirements

• Always use msbuild /t:rebuild to build the solution or projects instead of dotnet build

Project File Management

Non-SDK Style Project Structure

.NET Framework projects use the legacy project format, which differs significantly from modern SDK-style projects:

• Explicit File Inclusion: All new source files MUST be explicitly added to the project file (.csproj) using a <Compile> element

  • .NET Framework projects do not automatically include files in the directory like SDK-style projects
  • Example: <Compile Include="Path\To\NewFile.cs" />

• No Implicit Imports: Unlike SDK-style projects, .NET Framework projects do not automatically import common namespaces or assemblies

• Build Configuration: Contains explicit <PropertyGroup> sections for Debug/Release configurations

• Output Paths: Explicit <OutputPath> and <IntermediateOutputPath> definitions

• Target Framework: Uses <TargetFrameworkVersion> instead of <TargetFramework>

  • Example: <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>

NuGet Package Management

• Installing and updating NuGet packages in .NET Framework projects is a complex task requiring coordinated changes to multiple files. Therefore, do not attempt to install or update NuGet packages in this project.
• Instead, if changes to NuGet references are required, ask the user to install or update NuGet packages using the Visual Studio NuGet Package Manager or Visual Studio package manager console.
• When recommending NuGet packages, ensure they are compatible with .NET Framework or .NET Standard 2.0 (not only .NET Core or .NET 5+).

C# Language Version is 7.3

• This project is limited to C# 7.3 features only. Please avoid using:

C# 8.0+ Features (NOT SUPPORTED):

• Using declarations (using var stream = ...)
• Await using statements (await using var resource = ...)
• Switch expressions (variable switch { ... })
• Null-coalescing assignment (??=)
• Range and index operators (array[1..^1], array[^1])
• Default interface methods
• Readonly members in structs
• Static local functions
• Nullable reference types (string?, #nullable enable)

C# 9.0+ Features (NOT SUPPORTED):

• Records (public record Person(string Name))
• Init-only properties ({ get; init; })
• Top-level programs (program without Main method)
• Pattern matching enhancements
• Target-typed new expressions (List<string> list = new())

C# 10+ Features (NOT SUPPORTED):

• Global using statements
• File-scoped namespaces
• Record structs
• Required members

Use Instead (C# 7.3 Compatible):

• Traditional using statements with braces
• Switch statements instead of switch expressions
• Explicit null checks instead of null-coalescing assignment
• Array slicing with manual indexing
• Abstract classes or interfaces instead of default interface methods

Environment Considerations (Windows environment)

• Use Windows-style paths with backslashes (e.g., C:\path\to\file.cs)
• Use Windows-appropriate commands when suggesting terminal operations
• Consider Windows-specific behaviors when working with file system operations

Common .NET Framework Pitfalls and Best Practices

Async/Await Patterns

• ConfigureAwait(false): Always use ConfigureAwait(false) in library code to avoid deadlocks:

  var result = await SomeAsyncMethod().ConfigureAwait(false);
  

• Avoid sync-over-async: Don't use .Result or .Wait() or .GetAwaiter().GetResult(). These sync-over-async patterns can lead to deadlocks and poor performance. Always use await for asynchronous calls.

DateTime Handling

• Use DateTimeOffset for timestamps: Prefer DateTimeOffset over DateTime for absolute time points
• Specify DateTimeKind: When using DateTime, always specify DateTimeKind.Utc or DateTimeKind.Local
• Culture-aware formatting: Use CultureInfo.InvariantCulture for serialization/parsing

String Operations

• StringBuilder for concatenation: Use StringBuilder for multiple string concatenations
• StringComparison: Always specify StringComparison for string operations:

  string.Equals(other, StringComparison.OrdinalIgnoreCase)
  

Memory Management

• Dispose pattern: Implement IDisposable properly for unmanaged resources
• Using statements: Always wrap IDisposable objects in using statements
• Avoid large object heap: Keep objects under 85KB to avoid LOH allocation

Configuration

• Use ConfigurationManager: Access app settings through ConfigurationManager.AppSettings
• Connection strings: Store in <connectionStrings> section, not <appSettings>
• Transformations: Use web.config/app.config transformations for environment-specific settings

Exception Handling

• Specific exceptions: Catch specific exception types, not generic Exception
• Don't swallow exceptions: Always log or re-throw exceptions appropriately
• Use using for disposable resources: Ensures proper cleanup even when exceptions occur

Performance Considerations

• Avoid boxing: Be aware of boxing/unboxing with value types and generics
• String interning: Use string.Intern() judiciously for frequently used strings
• Lazy initialization: Use Lazy<T> for expensive object creation
• Avoid reflection in hot paths: Cache MethodInfo, PropertyInfo objects when possible