# UIntPtr

***

**1. Retrieving the Address of a Variable**

```csharp
int i = 5;
UIntPtr iPtr = (UIntPtr)&i;
```

**2. Passing a Pointer to a Function**

```csharp
[DllImport("NativeLib.dll")]
private static extern void SetValue(UIntPtr ptr, int value);
SetValue(iPtr, 10);
```

**3. Converting Between Pointer and Integer**

```csharp
int i = 5;
UIntPtr iPtr = new UIntPtr(i);
int i2 = iPtr.ToUInt32();
```

**4. Comparing Pointers**

```csharp
UIntPtr iPtr1 = (UIntPtr)&i;
UIntPtr iPtr2 = (UIntPtr)&i;
bool isEqual = (iPtr1 == iPtr2);
```

**5. Adding and Subtracting Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr iPtr2 = iPtr + 4; // Advance the pointer by 4 bytes
```

**6. Getting the Size of a Type**

```csharp
int size = Marshal.SizeOf<int>(); // Use sizeof() operator on UIntPtr
```

**7. Allocating and Freeing Memory**

```csharp
UIntPtr ptr = Marshal.AllocHGlobal(100);
Marshal.FreeHGlobal(ptr);
```

**8. Accessing Memory at a Specified Address**

```csharp
byte value = Marshal.ReadByte((UIntPtr)0x12345678);
Marshal.WriteByte((UIntPtr)0x12345678, 5);
```

**9. Using Pointers in Structures**

```csharp
[StructLayout(LayoutKind.Explicit)]
struct MyStruct
{
    [FieldOffset(0)]
    public UIntPtr ptr;
}
```

**10. Using Pointers in Arrays**

```csharp
int[] arr = new int[5];
UIntPtr[] arrPtrs = new UIntPtr[5];
for (int i = 0; i < 5; i++)
{
    arrPtrs[i] = (UIntPtr)&arr[i];
}
```

**11. Using Pointers in Delegates**

```csharp
delegate void MyDelegate(UIntPtr ptr);
MyDelegate myDelegate = (UIntPtr ptr) => { /* Do something with the pointer */ };
```

**12. Using Pointers in Events**

```csharp
public class MyEvent
{
    public event EventHandler<UIntPtr> MyEvent;
}
```

**13. Using Pointers in Properties**

```csharp
public class MyProperty
{
    private UIntPtr ptr;
    public UIntPtr MyPtr
    {
        get { return ptr; }
        set { ptr = value; }
    }
}
```

**14. Using Pointers in Indexers**

```csharp
public class MyIndexer
{
    private UIntPtr[] ptrs;
    public UIntPtr this[int index]
    {
        get { return ptrs[index]; }
        set { ptrs[index] = value; }
    }
}
```

**15. Using Pointers in LINQ Queries**

```csharp
var query = from ptr in ptrs
            where ptr != null
            select ptr;
```

**16. Using Pointers in Unsafe Code**

```csharp
unsafe
{
    int* iPtr = &i;
    *iPtr = 10;
}
```

**17. Comparing Pointers Using the == and != Operators**

```csharp
UIntPtr iPtr1 = (UIntPtr)&i;
UIntPtr iPtr2 = (UIntPtr)&i;
bool isEqual = (iPtr1 == iPtr2); // True
```

**18. Comparing Pointers Using the CompareTo Method**

```csharp
UIntPtr iPtr1 = (UIntPtr)&i;
UIntPtr iPtr2 = (UIntPtr)&i;
int result = iPtr1.CompareTo(iPtr2); // 0
```

**19. Creating a UIntPtr from an Integer**

```csharp
UIntPtr iPtr = new UIntPtr(10);
```

**20. Creating a UIntPtr from a Pointer**

```csharp
int* iPtr = &i;
UIntPtr uIntPtr = new UIntPtr(iPtr);
```

**21. Getting the Value of a Pointer**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
int value = iPtr.ToUInt32(); // 5
```

**22. Setting the Value of a Pointer**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
iPtr.ToUInt32() = 10; // Changes the value of i to 10
```

**23. Incrementing and Decrementing Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
iPtr++; // Advances the pointer by 4 bytes
iPtr--; // Moves the pointer back by 4 bytes
```

**24. Adding and Subtracting Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr jPtr = (UIntPtr)&j;
UIntPtr sum = iPtr + jPtr; // Adds the two pointers
UIntPtr diff = iPtr - jPtr; // Subtracts the two pointers
```

**25. Multiplying and Dividing Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr jPtr = (UIntPtr)&j;
UIntPtr prod = iPtr * jPtr; // Multiplies the two pointers
UIntPtr quot = iPtr / jPtr; // Divides the two pointers
```

**26. Taking the Address of a Pointer**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr iPtrPtr = (UIntPtr)&iPtr; // Gets the address of the pointer
```

**27. Passing a Pointer as an Argument**

```csharp
void MyFunction(UIntPtr ptr)
{
    // Do something with the pointer
}
```

**28. Returning a Pointer from a Function**

```csharp
UIntPtr MyFunction()
{
    return (UIntPtr)&i;
}
```

**29. Using Pointers in Delegates**

```csharp
delegate void MyDelegate(UIntPtr ptr);
```

**30. Using Pointers in Events**

```csharp
public class MyEvent
{
    public event EventHandler<UIntPtr> MyEvent;
}
```

**31. Using Pointers in Properties**

```csharp
public class MyProperty
{
    private UIntPtr ptr;
    public UIntPtr MyPtr
    {
        get { return ptr; }
        set { ptr = value; }
    }
}
```

**32. Using Pointers in Indexers**

```csharp
public class MyIndexer
{
    private UIntPtr[] ptrs;
    public UIntPtr this[int index]
    {
        get { return ptrs[index]; }
        set { ptrs[index] = value; }
    }
}
```

**33. Using Pointers in LINQ Queries**

```csharp
var query = from ptr in ptrs
            where ptr != null
            select ptr;
```

**34. Using Pointers in Unsafe Code**

```csharp
unsafe
{
    int* iPtr = &i;
    *iPtr = 10;
}
```

**35. Comparing Pointers Using the == and != Operators**

```csharp
UIntPtr iPtr1 = (UIntPtr)&i;
UIntPtr iPtr2 = (UIntPtr)&i;
bool isEqual = (iPtr1 == iPtr2); // True
```

**36. Comparing Pointers Using the CompareTo Method**

```csharp
UIntPtr iPtr1 = (UIntPtr)&i;
UIntPtr iPtr2 = (UIntPtr)&i;
int result = iPtr1.CompareTo(iPtr2); // 0
```

**37. Creating a UIntPtr from an Integer**

```csharp
UIntPtr iPtr = new UIntPtr(10);
```

**38. Creating a UIntPtr from a Pointer**

```csharp
int* iPtr = &i;
UIntPtr uIntPtr = new UIntPtr(iPtr);
```

**39. Getting the Value of a Pointer**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
int value = iPtr.ToUInt32(); // 5
```

**40. Setting the Value of a Pointer**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
iPtr.ToUInt32() = 10; // Changes the value of i to 10
```

**41. Incrementing and Decrementing Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
iPtr++; // Advances the pointer by 4 bytes
iPtr--; // Moves the pointer back by 4 bytes
```

**42. Adding and Subtracting Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr jPtr = (UIntPtr)&j;
UIntPtr sum = iPtr + jPtr; // Adds the two pointers
UIntPtr diff = iPtr - jPtr; // Subtracts the two pointers
```

**43. Multiplying and Dividing Pointers**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr jPtr = (UIntPtr)&j;
UIntPtr prod = iPtr * jPtr; // Multiplies the two pointers
UIntPtr quot = iPtr / jPtr; // Divides the two pointers
```

**44. Taking the Address of a Pointer**

```csharp
UIntPtr iPtr = (UIntPtr)&i;
UIntPtr iPtrPtr = (UIntPtr)&iPtr; // Gets the address of the pointer
```

**45. Passing a Pointer as an Argument**

```csharp
void MyFunction(UIntPtr ptr)
{
    // Do something with the pointer
}
```

**46. Returning a Pointer from a Function**

```csharp
UIntPtr MyFunction()
{
    return (UIntPtr)&i;
}
```

**47. Using Pointers in Delegates**

```csharp
delegate void MyDelegate(UIntPtr ptr);
```

**48. Using Pointers in Events**

```csharp
public class MyEvent
{
    public event EventHandler<UIntPtr> MyEvent;
}
```

**49. Using Pointers in Properties**

```csharp
public class MyProperty
{
    private UIntPtr ptr;
    public UIntPtr MyPtr
    {
        get { return ptr; }
        set { ptr = value; }
    }
}
```

**50. Using Pointers in Indexers**

```csharp
public class MyIndexer
{
    private UIntPtr[] ptrs;
    public UIntPtr this[int index]
    {
        get { return ptrs[index]; }
        set { ptrs[index] = value; }
    }
}
```