The ```Stack<T>``` generic class in the ```System.Collections.Generic``` namespace provides the **```Push()``` method**, which inserts an element to the top of a stack in C#.

#   
## Syntax
```
public void Push (T item);
```
- This method takes the value ```T``` as input to be pushed onto the ```Stack<T>```.
- The value ```T``` can be ```null``` for reference types.


#   
## Things to Note
- The ```Stack<T>``` class internally uses an array to store the elements.
- This method is an _O(1)_ operation if the number of elements in the stack is less than its capacity.
- When we add a new element using ``` 
Push()```, and the current count of elements in the stack is equal to its capacity, a new array double the size of the initial capacity is allocated. Existing elements are copied over to the new array. After that, the new element is added to the stack. 

- When the count of elements is equal to the capacity, ```Push()``` method is an _O(n)_ operation, where n is the count of the elements.

#   
## Code 
In the following code, we have created a stack of strings.

First, we call the ```Push()``` method with the `Asia` string and then the `Africa` string. This inserts both strings onto the stack, with `Africa` at the top of the stack.

We then show all the stack elements, and we can see that it has `Africa` at the top, followed by `Asia`.

We again call the ```Push()``` method with the `Europe` string as input, and it inserts `Europe` at the top of the stack. This stack is a #key# LIFO: Last In First Out #key# data structure.

Later, we again display all elements of the stack and can observe that `Europe` is at the top of the stack.

The program below shows the output and exits.

```
Current Stack Items: 
Africa, Asia

Pushing 'Europe' to the Stack..

Stack Items:
Europe, Africa, Asia
```


using System;
using System.Collections.Generic;

class StackPush
{
    static void Main()
    {
        Stack<string> stack = new Stack<string>();
        stack.Push("Asia");
        stack.Push("Africa");     

        Console.WriteLine("Current Stack Items: \n{0}\n", string.Join(",", stack.ToArray()));
        Console.WriteLine("Pushing 'Europe' to the Stack..\n");
        stack.Push("Europe");
        Console.WriteLine("Stack Items:\n{0}", string.Join(",", stack.ToArray()));

    }
}

How to push an element to a stack in C#

Use Stack<T>.Push() in C# for efficient element insertion; O(1) if under capacity, O(n) if resizing.