> For the complete documentation index, see [llms.txt](https://f1rstbyt3.gitbook.io/hacking-notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://f1rstbyt3.gitbook.io/hacking-notes/misc/coding/c.md).

# C\#

#### Data Types:

Data types in C# are referred to as "value types" and "reference types".

When a value type is declared, the data is stored in the memory location of the variable.  \
When a reference type is declared, the data is stored somewhere else in memory and the variable contains a pointer it.

* Reference types are always allocated in heap memory, 
* value types can be allocated on the heap or on the stack depending on where they're declared.  

If a value type is declared inside a method, then it's stored on the stack.  If it's declared in a class, then the data is stored on the heap.  This is because a class is a reference type, which must always be stored on the heap.  

Value types include `int`, `byte`, `bool`, and `char`.  Reference types include `string`, `arrays` and `class`.

#### Integers:

An integer to be negative, it should be declared as a "signed" integer. Otherwise, it can be "unsigned". Unsigned integers can be larger than signed integers because we're not wasting a "sign" bit. We can allocate different sizes for an integer in multiples of 8 bits: 8, 16, 32 and 64 bits.

| Keyword | Size            |
| ------- | --------------- |
| sbyte   | Signed 8-bit    |
| byte    | Unsigned 8-bit  |
| short   | Signed 16-bit   |
| ushort  | Unsigned 16-bit |
| int     | Signed 32-bit   |
| uint    | Unsigned 32-bit |
| long    | Signed 64-bit   |
| ulong   | Unsigned 64-bit |

A floating point is a number that can have decimal places, 8.2, 3.14, etc. declaring a float or double, the letter `F` or `D` should be appended to the value. There are three types (all of which are signed):

| Keyword | Size     |
| ------- | -------- |
| float   | 4 bytes  |
| double  | 8 bytes  |
| decimal | 16 bytes |

A `bool` is a true or false value

A `char` is a single letter or number, represented by an integer

The `array` and `tuple` are both types of collections

An array can hold multiple values of a single data type; whereas a tuple can hold multiple values but of various data types

A tuple is declared using parenthesise for both the data types and initial values; and instead of accessing a tuple index via square brackets, we use the period, `.`.  Each item is given a name like `Item1`, `Item2`, etc. Can use a concept called "deconstruction" to assign friendly variable names to your elements.

```
(string, string, int) tuple = ("duck", "goose", 2);
(string firstbird, string secondbird, int numerofbirds);
```

One way is via interpolation, denoted by a prepended `$`.  Another is by using the `+` operator. Or by using the `string.Concat()`

string has lots of really useful methods including `Split`, `Join`, `Equals`, and `IsNullOrEmpty`/`IsNullOrWhiteSpace`

C# uses different text casing depending on where it's being declared.  Here is a summary of the conventions:

| Object          | Casing      |
| --------------- | ----------- |
| Classes         | PascalCase  |
| Public Members  | PascalCase  |
| Private Members | \_camelCase |
| Methods         | PascalCase  |
| Variables       | camelCase   |
| Enums           | PascalCase  |

### lists: 

```csharp
var list1 = new List<int>();
var list2 = new List<int> {1,2,3,4,5};
list1.Add(item:1);
list1.Remove(item:1);
list2.RemoveAt(index:3);
if list2.Contains(item:3);    
var item:int = line2.Find(match:v:int => v == 3);

```

### Dictionaries:

```csharp
var dic = new Dictionary<int, string()>;
dic.Add(0, "value1");
dic.Add(1, "value2");
dic.Add(2, "value3");

foreach(var kvp:KeyValuePair<int,string> in dic)
    Console.Writeline($"Key: {kvp.Key} contains: {kvp.Value}")
    
if (dic.TryGetValue(2, out var value:string))
    console.writeline(value);

if (dic.ContainsKey(2))
    dic[2] = "Updated Value";
```

#### hashtables:

```csharp
var table = new Hashtable
{
    {0,"value1"}
    {1,"value2"}
    {2,"value3"}
};
foreach(DictionaryEntry entry in table)
    Console.Writeline($"Entry:{entry.Key} Value: {entry.Value}");
```

### Queues:&#x20;

#### FIFO:

```csharp
var queue1 = new Queue<int>();
queue1.Enque(item:1);
queue1.Enque(item:2);
queue1.Enque(item:3);

while (queue1.TryDequeue(out var value:int))
    Console.Writeline(value);
```

#### LIFO:

```csharp
var stack2 = new Stack<int>();
stack1.Push(item:1);
stack1.Push(item:2);
stack1.Push(item:3);

while (stack1.TryPop(out var value:int))
    Console.Writeline(value);
```

### Bitwise Operators:&#x20;

```csharp
var rand = new Random();
var i1 = rand.Next(0,100);
var i2 = rand.Next(0,100); 

Console.Writeline(i1 | i2}; // OR 
Console.Writeline(i1 && i2}; // and 
Console.Writeline(i1 << i2}; // shift left 
Console.Writeline(i1 >> i2}; // shift right
Console.Writeline(i1 ^ i2}; // XOR 
```

### If / Else:&#x20;

<pre class="language-csharp"><code class="lang-csharp"><strong>var condition1 = true;
</strong><strong>var condition2 = false;
</strong><strong>var condition3 = false;
</strong><strong>
</strong><strong>if (condition1 || condition2 &#x26;&#x26; condition3) //  = true - AND statement is evaluated first, followed by the OR.
</strong>if ((condition1 || condition2) &#x26;&#x26; condition3) // = false
<strong>{
</strong>    // do something 
}

var animal = "Dog";
var sound:string = animal switch
{
    "Dog" => "Woof",
    "Cat" => "Meow",
    _ => "who knows"  // The _ => is used as a "catch all" 
}
Console.Writeline(sound) 


</code></pre>

### For Loops:

* Statement 1 is executed one time at the start of the loop.
* Statement 2 defines the condition for executing the loop code.
* Statement 3 is executed after every loop.

```csharp
for (var i = 0; i < 10; i++)
    Console.WriteLine($"i == {i}");
    
var array = new[] {1,2,3,4,5};
for (var i = 0; array.Length; i++)
    Console.WriteLine($"Array: {array[i]}");
```

### While Loop:&#x20;

```csharp
while (i < 10) 
{
    Console.WriteLine(i);
    i++
}

// ForEach Loop
var list = new List<int> {1,2,3,4,5};
foreach(var i:int in list)
    Console.WriteLine(i); 
```

#### Taking Arguments:&#x20;

```csharp
using System;
namespace Args
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            if (args.Length >= 2)
            {
                for (var i = 0; i < args.Length; i++)
                    Console.WriteLine($"Argument {i+1} is {args[i]}");
            }
            else
            {
                Console.WriteLine("Not Enough Arguments");
                ShowUsage();
                return;
            }

            void ShowUsage()
            {
                Console.WriteLine("Usage: app.exe <argv1> <argv2>");
            }
        }
    }
}
```

### Input:

```csharp
using System;
namespace ConsoleApplication1
{
    internal class Program
    {
        public static void Main(string[] args)
        {
            void ShowUsage()
            {
                Console.WriteLine("Enter a word to echo, or enter exit to quit");
            }
            ShowUsage();
            while (true)
            {
                // create a promtp
                Console.Write("> ");    
                // read user input
                var input = Console.ReadLine();
                // if blank promt again
                if (string.IsNullOrWhiteSpace(input))
                {
                    ShowUsage();
                    continue;
                }
                else if (input.Equals("exit", StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine("> Now exiting");
                    break;
                }
                else
                {
                Console.WriteLine($"You Said {input}");
                }
            }
        }
    }
}
```

### Object orientation:&#x20;

```csharp
using System;
using System.Runtime.Remoting.Metadata.W3cXsd2001;

var person = new Person
{
    FirstName = "James",
    LastName = "Hammond",
};
Console.WriteLine(person.FullName);

public

internal class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string FullName => $"{FirstName} {LastName}";
};

```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://f1rstbyt3.gitbook.io/hacking-notes/misc/coding/c.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.