unsafe

Should you use pointers in your C# code? What are the benefits? Is it recommend by The Man (Microsoft)? From "The Man" himself: The use of pointers is rarely required in C#, but there are some situations that require them. As examples, using an unsafe context to allow pointers is warranted by the following cases: Dealing with existing structures on disk Advanced COM or Platform Invoke scenarios that involve structures with pointers in them Performance-critical code The use of unsafe context in other situations is discouraged. Specifically, an unsafe context should not be used to attempt to

Question I'm porting a C application into C#. The C app calls lots of functions from a 3rd-party DLL, so I wrote P/Invoke wrappers for these functions in C#. Some of these C functions allocate data which I have to use in the C# app, so I used IntPtr 's, Marshal.PtrToStructure and Marshal.Copy to copy the native data (arrays and structures) into managed variables. Unfortunately, the C# app proved to be much slower than the C version. A quick performance analysis showed that the above mentioned marshaling-based data copying is the bottleneck. I'm considering to speed up the C# code by rewriting

I know C# gives the programmer the ability to access, use pointers in an unsafe context. But When is this needed? At what circumstances, using pointers becomes inevitable? Is it only for performance reasons? Also why does C# expose this functionality through an unsafe context, and remove all of the managed advantages from it? Is it possible to have use pointers without losing any advantages of managed environment, theoretically? When is this needed? Under what circumstances does using pointers becomes inevitable? When the net cost of a managed, safe solution is unacceptable but the net cost of

I have code that creates a RefCell and then wants to pass a reference to that RefCell to a single thread: extern crate crossbeam; use std::cell::RefCell; fn main() { let val = RefCell::new(1); crossbeam::scope(|scope| { scope.spawn(|| *val.borrow()); }); } In the complete code, I'm using a type that has a RefCell embedded in it (a typed_arena::Arena ). I'm using crossbeam to ensure that the thread does not outlive the reference it takes. This produces the error: error: the trait bound `std::cell::RefCell<i32>: std::marker::Sync` is not satisfied [E0277] scope.spawn(|| *val.borrow()); ^~~~~ I

I have a massive vector that I want to be able to load/act on in parallel, e.g. load first hundred thousand indices in one thread, next in another and so on. As this is going to be a very hot part of the code, I have come up with this following proof of concept unsafe code to do this without Arcs and Mutexes: let mut data:Vec<u32> = vec![1u32, 2, 3]; let head = data.as_mut_ptr(); let mut guards = (0..3).map(|i| unsafe { let mut target = std::ptr::Unique::new(head.offset(i)); let guard = spawn(move || { std::ptr::write(target.get_mut(), 10 + i as u32); }); guard }); Is there anything I have

I understand unsafe code is more appropriate to access things like the Windows API and do unsafe type castings than to write more performant code, but I would like to ask you if you have ever noticed any significant performance improvement in real-world applications by using it when compared to safe c# code. Some Performance Measurements The performance benefits are not as great as you might think. I did some performance measurements of normal managed array access versus unsafe pointers in C#. Results from a build run outside of Visual Studio 2010, .NET 4, using an Any CPU | Release build on