> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C# void The `void` keyword in C# specifies that a method does not return a value. When used as a method's return type, it instructs the compiler that the method will terminate without pushing a return value onto the evaluation stack, and the caller cannot assign the result of the method invocation to a variable. ## Type System Mechanics In the .NET Common Type System (CTS), the `void` keyword maps to the `System.Void` structure. Despite being a struct in the CTS, C# enforces strict semantic rules that prevent `void` from being used as a standard data type. * You cannot declare a variable, field, property, or parameter of type `void`. * You cannot instantiate `System.Void`. * You cannot use `void` as a generic type argument (e.g., `Task` or `Func`). * You can evaluate `typeof(void)` strictly for reflection purposes (e.g., inspecting method signatures at runtime). ```csharp theme={"dark"} // Valid: Method signature indicating no return value public void TerminateProcess() { // Implicitly returns at the end of the block, // or explicitly via an empty return statement: return; } // Valid: Reflection evaluation Type returnType = typeof(void); // Invalid: Compilation errors // void x; // public void Process(void input) { } ``` ## Generics and the Unit Type Because `void` is invalid as a generic type argument, the C# type system necessitates separate non-generic types and delegates to represent void-returning operations. For example, the framework provides `Action` instead of `Func`, and `Task` instead of `Task`. When an architectural pattern (such as CQRS) or a generic interface strictly requires a return type argument, but the logical operation yields no data, `void` cannot be used. Instead, developers must use a "unit type" to satisfy the generic constraint. The `System.ValueTuple` (often represented syntactically as `()`) or custom unit structs are utilized to represent a type with exactly one value, fulfilling the generic signature without allocating meaningful data. ```csharp theme={"dark"} // Invalid: Compilation errors due to void in generics // Task invalidTask; // Func invalidFunc; // IRequestHandler invalidHandler; // Valid: Using non-generic equivalents Task validTask; Action validAction; // Valid: Using a unit type (ValueTuple) to satisfy a generic return constraint IRequestHandler validHandler; ``` ## Asynchronous Mechanics In asynchronous programming, `void` fundamentally alters the state machine generated by the compiler compared to returning a `Task`. An `async void` method lacks a return object, meaning the caller has no mechanism to track its completion status or `await` its execution. Crucially, unhandled exceptions within an `async void` method cannot be caught by the caller. Instead, the compiler generates code that posts the exception directly to the active `SynchronizationContext` (or the thread pool if none exists), which typically terminates the application process. ```csharp theme={"dark"} // The caller cannot await this method or catch its exceptions public async void ExecuteFireAndForget() { await Task.Delay(100); throw new InvalidOperationException(); // Crashes the process } ``` ## Pointer Mechanics (`void*`) Within an `unsafe` context, `void*` serves as an untyped pointer. It holds a memory address but provides no metadata about the size or layout of the data residing at that address. Because the compiler does not know the underlying type, a `void*` cannot be directly dereferenced or used in pointer arithmetic. It must be explicitly cast to a typed pointer (e.g., `byte*` or `int*`) before memory manipulation can occur. ```csharp theme={"dark"} unsafe { int value = 1024; // void* holds the address but strips type metadata void* untypedPointer = &value; // Invalid: Cannot dereference a void* // int readValue = *untypedPointer; // Valid: Must cast to a typed pointer first int* typedPointer = (int*)untypedPointer; int readValue = *typedPointer; } ```

Tired of Poor C# Skills? Fix That With Deep Grasping! Learn More