Unsafe
Download as PPT, PDF2 likes999 views
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 &.
Unsafe
- 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.