Unsafe code in C# uses pointers which allow it to perform similar high-performance systems programming as C++. Pointers must be enabled using the unsafe keyword and can cause problems if the garbage collector moves objects in memory. The fixed keyword is used to prevent objects from being moved while a pointer references it. Pointers are declared using a * and can be dereferenced using * or take the address of a variable using &.

1. Unsafe

2. • Unsafe code often involves the use of
pointers.
• Unsafe code and pointers enable C# to be
used to create applications that one might
normally associate with C++: highperformance, systems code.
• the inclusion of unsafe code and pointers
gives C# capabilities that are lacking in Java.

3. • Unsafe code is not code that is poorly written; it
is code that does not execute under the full
management of the common language runtime
(CLR).
• C# is normally used to create managed code.
• It is possible, however, to write code that does
not execute under the full control of the CLR. This
unmanaged code is not subject to the same
controls and constraints as managed code, so it
is called “unsafe”.
• it is not possible to verify that it won’t perform
some type of harmful action.

4. • Because a pointer can point anywhere in
memory, it is possible to misuse a pointer.
• It is also easy to introduce a coding error
when using pointers. This is why C# does not
support pointers when creating managed
code.
• C# does allow you to create and use pointers.
However, all pointer operations must be
marked as unsafe since they execute outside
the managed context.

5. Declaring a Pointer
• Pointer variables must be declared as such.
type * var-name ;
• type is the pointer’s referent type.
• var-name is the name of the pointer variable.
• example. To declare ip to be a pointer to an
int, use this declaration:
int* ip;

6. • If you come from a C/C++ background, then
you need to be aware of an important
difference between the way C# and C/C++
declare pointers.
• When you declare a pointer type in C/C++, the
* is not distributive over a list of variables in
a declaration.
• Thus, in C/C++, this statement
int* p, q;

7. • in C#, the * is distributive and the declaration
int* p, q;
• creates two pointer variables.
• Thus, in C# it is the same as these two
declarations:
int* p;
int* q;

8. • Two operators are used with pointers: * and
&.
• The & is a unary operator that returns the
memory address of its operand.
• int* ip;
• int num = 10;
• ip = #
• puts into ip the memory address of the
variable num.
• ip does not contain the value 10.

9. • The second operator is *, and it is the
complement of &.
• it refers to the value of the variable pointed
to by a pointer.
• ip = #
• int val = *ip;
• will place into val the value 10, which is the
value of num, which is pointed to by ip .

10. unsafe
• Any code that uses pointers must be marked
as unsafe by using the unsafe keyword.
• You can mark types (such as classes and
structures), members (such as methods and
operators), or individual blocks of code as
unsafe.
• using System;
• class UnsafeCode {

11. // Mark Main as unsafe.
unsafe static void Main() {
int count = 99;
int* p; // create an int pointer
p = &count; // put address of count into p
Console.WriteLine("Initial value of count is "
+*p);
*p = 10; // assign 10 to count via p
Console.WriteLine("New value of count is " + *p);
}}

12. Using fixed
• The fixed keyword can be used only in an
unsafe context.
• The fixed modifier is often used when working
with pointers.
• It prevents a variable from being moved by
the garbage collector.
• This is needed when a pointer refers to a field
in a class object.

13. • Using pointers in C# require much more
attention then in C++. That is because of
garbage collector (g.c.) which can run memory
cleaning. During cleaning, g.c. can change
physical position of the objects. If g.c. changes
position of an object the pointer will point at
wrong place in memory. To avoid such
problems (connected with garbage collector)
C# contains 'fixed' keyword. It informs system
not to relocate an object by the garbage
collector.

14. •
•
•
•
using System;
class Test {
public int num;
public Test(int i) { num = i; }
•}
• class FixedCode {
• // Mark Main as unsafe.
• unsafe static void Main() {

15. Test o = new Test(19);
fixed (int* p = &o.num) {
Console.WriteLine("Initial value of o.num is " + *p);
*p = 10;
Console.WriteLine("New value of o.num is " + *p);
} }
• fixed prevents o from being moved. Because p
points to o.num , if o were moved, then p
would point to an invalid location.