C# IntPtr.ToPointer方法代码示例

 public unsafe UmsManager(FileAccess access, byte[] seedData)
 {
     int memorySizeInBytes = seedData.Length;
     _memory = Marshal.AllocHGlobal(memorySizeInBytes);
     byte* destination = (byte*)_memory.ToPointer();
     fixed (byte* source = seedData)
     {
         Buffer.MemoryCopy(source, destination, memorySizeInBytes, memorySizeInBytes);
     }
     _stream = new UnmanagedMemoryStream(destination, memorySizeInBytes, memorySizeInBytes, access);
 }

        public static void CopyUnmanagedMemory(IntPtr src, int srcOffset, IntPtr dst, int dstOffset, int count)
        {
            unsafe
            {
                var srcPtr = (byte*) src.ToPointer();
                srcPtr += srcOffset;
                var dstPtr = (byte*) dst.ToPointer();
                dstPtr += dstOffset;

                memcpy(dstPtr, srcPtr, count);
            }
        }

 public unsafe UmsManager(FileAccess access, byte[] seedData)
 {
     _memorySizeInBytes = seedData.Length;
     unsafe
     {
         _memory = Marshal.AllocHGlobal(_memorySizeInBytes);
         byte* bytes = (byte*)_memory.ToPointer();
         byte* currentByte = bytes;
         for (int index = 0; index < _memorySizeInBytes; index++)
         {
             *currentByte = seedData[index];
         }
         _stream = new UnmanagedMemoryStream(bytes, _memorySizeInBytes, _memorySizeInBytes, access);
     }
 }

    unsafe public bool PosTest1(string id, long anyValue)
    {
        bool retVal = true;
        try
        {
            System.IntPtr ip = new IntPtr((void *)anyValue);
            if (ip.ToPointer() != (void*)anyValue)
            {
                TestLibrary.TestFramework.LogError(id, String.Format("expect IntPtr value is {0}", anyValue));
                retVal = false;
            }
        }
        catch (Exception e)
        {
            TestLibrary.TestFramework.LogError(id, "Unexpected exception: " + e);
            retVal = false;
        }


        return retVal;
    }

        //
        // Wrapper for calling RaiseFailFastException
        //
        internal static unsafe void RaiseFailFastException(uint faultCode, IntPtr pExContext)
        {
            long ctxIP = 0;
            Interop._CONTEXT* pContext = (Interop._CONTEXT*)pExContext.ToPointer();
            if (pExContext != IntPtr.Zero)
            {
#if AMD64
                ctxIP = (long)pContext->Rip;
#elif ARM
                ctxIP = (long)pContext->Pc;
#elif X86
                ctxIP = (long)pContext->Eip;
#else
                System.Diagnostics.Debug.Assert(false, "Unsupported architecture");
#endif
            }

            _EXCEPTION_RECORD exceptionRecord;
            exceptionRecord.ExceptionCode = faultCode;
            exceptionRecord.ExceptionFlags = (uint)Constants.ExceptionNonContinuable;
            exceptionRecord.ExceptionRecord = IntPtr.Zero;
            exceptionRecord.ExceptionAddress = new IntPtr(ctxIP);  // use the IP set in context record as the exception address
            exceptionRecord.NumberParameters = 0;
            // don't care about exceptionRecord.ExceptionInformation as we set exceptionRecord.NumberParameters to zero

            PInvoke_RaiseFailFastException(
                &exceptionRecord,
                pContext,
                ctxIP == 0 ? (uint)Constants.FailFastGenerateExceptionAddress : 0);
        }

    /// <summary>
    /// erstellt einen neuen Hash-Eintrag (darf noch nicht vorhanden sein)
    /// </summary>
    /// <param name="code">Hash-Code, welcher eintragen werden soll</param>
    /// <param name="tiefe">entsprechende Zugtiefe</param>
    public void Add(ulong code, int tiefe)
    {
#if multiHash
      var hash = hashes[code & hashesBits];
#endif
      hash.Add(code, (ushort)tiefe);

      if (hash.Count > dictionaryLimit)
      {
#if Index0
        Array.Resize(ref weitere, weitere.Length + 1);
        for (int i = weitere.Length - 1; i > 0; i--) weitere[i] = weitere[i - 1];
        weitere[0] = hash;
        hash = new Dictionary<ulong, ushort>();
#endif

#if Index16
        if (archivAnzahl == 0)
        {
          #region # // --- Archiv das erste mal erstellen ---
          // --- Archiv vorbereiten ---
#if multiHash
          archivAnzahl = hashes.Sum(x => x.Count);
#else
          archivAnzahl = hash.Count;
#endif

          archivDataPointer = Marshal.AllocHGlobal((IntPtr)((long)archivAnzahl * 8L));
          if (archivDataPointer == IntPtr.Zero) throw new Exception("Speicher konnte nicht reserviert werden (" + (((long)archivAnzahl * 8L) / 1048576L) + " MB)");
          archivData = (ulong*)archivDataPointer.ToPointer();

          uint[] zähler = new uint[1 << 16];
#if multiHash
          foreach (var h in hashes)
          {
            h.Select(x => zähler[x.Key & 0xffff]++).Count();
          }
#else
          hash.Select(x => zähler[x.Key & 0xffff]++).Count();
#endif
          uint[] posis = new uint[1 << 16];
          uint pos = 0;
          for (int i = 1; i < (1 << 16); i++)
          {
            pos += zähler[i - 1];
            posis[i] = pos;
          }

          // --- Archiv befüllen ---
#if multiHash
          foreach (var h in hashes) foreach (var satz in h)
#else
          foreach (var satz in hash)
#endif
            {
              int indexPos = (int)(satz.Key & 0xffff);
              archivData[posis[indexPos]++] = (satz.Key & 0xffffffffffff0000) | (ulong)satz.Value;
            }

          // --- Positionen neu berechnen ---
          posis[0] = pos = 0;
          for (int i = 1; i < (1 << 16); i++)
          {
            pos += zähler[i - 1];
            posis[i] = pos;
          }

          // --- Archiv sortieren (Multi-Threaded) ---
          ParallelEnumerable.Range(0, 1 << 16).Select(i =>
          {
            Sort.Quick(&archivData[posis[i]], (int)zähler[i]);
            return i;
          }).Count();

          // --- 16 Bit-Index erstellen ---
          uint[] indexTemp = Enumerable.Range(0, (1 << 16) * 2).Select(i => (i & 1) == 0 ? zähler[i >> 1] : posis[i >> 1]).ToArray();

          for (int i = 0; i < indexTemp.Length; i++) archivIndex[i] = indexTemp[i];
          #endregion
        }
        else
        {
          #region # // --- Archiv erweitern ---
          // --- Neue Daten vorbereiten ---
          int dazuAnzahl = hash.Count;
          ulong[] dazuData = new ulong[dazuAnzahl];
          uint[] zähler = new uint[1 << 16];
          hash.Select(x => zähler[x.Key & 0xffff]++).Count();
          uint[] posis = new uint[1 << 16];
          uint pos = 0;
          for (int i = 1; i < (1 << 16); i++)
          {
            pos += zähler[i - 1];
            posis[i] = pos;
          }
//.........这里部分代码省略.........

 internal unsafe Libgit2Object(IntPtr ptr, bool owned)
     : this(ptr.ToPointer(), owned)
 {
 }

 /// <summary>
 /// Fill memory region with specified value.
 /// </summary>
 /// 
 /// <param name="dst">Destination pointer.</param>
 /// <param name="filler">Filler byte's value.</param>
 /// <param name="count">Memory block's length to fill.</param>
 /// 
 /// <returns>Return's value of <paramref name="dst"/> - pointer to destination.</returns>
 /// 
 public static IntPtr SetUnmanagedMemory(IntPtr dst, int filler, int count)
 {
     unsafe
     {
         SetUnmanagedMemory((byte*)dst.ToPointer(), filler, count);
     }
     return dst;
 }

    public SokowahnHash_Index24()
#endif
#endif
    {
#if multiHash
      hashes = new Dictionary<ulong, ushort>[hashesAnzahl];
      for (int i = 0; i < hashes.Length; i++) hashes[i] = new Dictionary<ulong, ushort>();
#else
      hash = new Dictionary<ulong, ushort>();
#endif

#if Index16
      archivIndexPointer = Marshal.AllocHGlobal((1 << 16) * 2 * 4);
      if (archivIndexPointer == IntPtr.Zero) throw new Exception("Speicher konnte nicht reserviert werden (" + (((1 << 16) * 2 * 4) / 1048576L) + " MB)");
      archivIndex = (uint*)archivIndexPointer.ToPointer();
      for (int i = 0; i < (1 << 16) * 2; i++) archivIndex[i] = 0;
#endif

#if Index24
      archivIndexPointer = Marshal.AllocHGlobal((1 << 24) * 2 * 4);
      if (archivIndexPointer == IntPtr.Zero) throw new Exception("Speicher konnte nicht reserviert werden (" + (((1 << 24) * 2 * 4) / 1048576L) + " MB)");
      archivIndex = (uint*)archivIndexPointer.ToPointer();
      for (int i = 0; i < (1 << 24) * 2; i++) archivIndex[i] = 0;
#endif
    }

 unsafe static void OnCallback(IntPtr handle, int status)
 {
     uv_req_t* uvRequest = (uv_req_t*)handle.ToPointer();
     var request = GCHandle.FromIntPtr(uvRequest->data).Target as CallbackRequest;
     if (request == null)
     {
         throw new Exception("invalid callback");
     }
     else
     {
         request.Callback(status);
         request.Dispose();
     }
 }

 /// <summary>
 /// Copy block of unmanaged memory.
 /// </summary>
 /// 
 /// <param name="dst">Destination pointer.</param>
 /// <param name="src">Source pointer.</param>
 /// <param name="count">Memory block's length to copy.</param>
 /// 
 /// <returns>Return's value of <paramref name="dst"/> - pointer to destination.</returns>
 /// 
 /// <remarks><para>This function is required because of the fact that .NET does
 /// not provide any way to copy unmanaged blocks, but provides only methods to
 /// copy from unmanaged memory to managed memory and vise versa.</para></remarks>
 ///
 public static IntPtr CopyUnmanagedMemory(IntPtr dst, IntPtr src, int count)
 {
     unsafe
     {
         CopyUnmanagedMemory((byte*)dst.ToPointer(), (byte*)src.ToPointer(), count);
     }
     return dst;
 }

 public unsafe virtual bool runTest()
   {
   Console.Error.WriteLine(s_strTFPath + " " + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
   int iCountErrors = 0;
   int iCountTestcases = 0;
   String strLoc = "Loc_000oo";
   IntPtr ip1;
   void* vd1;
   void* vd2;
   int* iptr1;
   Int32 iValue;          
   Int64 lValue;
   Boolean fValue;
   Char chValue;
   Byte btValue;
   SByte sbValue;
   Int16 sValue;
   UInt16 usValue;
   UInt32 uiValue;
   UInt64 ulValue;
   DateTime dt1;
   String strValue;
   Int32[] iArr = {1, 2, 3, 4, 5};
   MyEnum en1;
   String strReturned;
   try {
   strLoc = "Loc_743wg";
   iValue = 16;
   vd1 = &iValue;
   ip1 = new IntPtr(vd1);
   vd2 = ip1.ToPointer();
   iCountTestcases++;
   if((*((int*)vd2)) != iValue){
   iCountErrors++;
   Console.WriteLine("Err_2975sf! Wrong value returned, " + (*((int*)vd2)));
   }
   strLoc = "Loc_0084wf";
   lValue = 16;
   vd1 = &lValue;
   ip1 = new IntPtr(vd1);
   vd2 = ip1.ToPointer();
   iCountTestcases++;
   if((*((long*)vd2)) != lValue){
   iCountErrors++;
   Console.WriteLine("Err_974325sdg! Wrong value returned");
   }
   strLoc = "Loc_0084wf";
   lValue = 16;
   vd1 = &lValue;
   ip1 = new IntPtr(vd1);
   iptr1 = (int*)ip1.ToPointer();
   iCountTestcases++;
   if((*iptr1) != lValue){
   iCountErrors++;
   Console.WriteLine("Err_974325sdg! Wrong value returned! check the endiannees of this machine!!!, " + (*iptr1));
   }
   strLoc = "Loc_00845wsdg";
   lValue = Int64.MaxValue;
   vd1 = &lValue;
   ip1 = new IntPtr(vd1);
   vd2 = ip1.ToPointer();
   iCountTestcases++;
   if((*((long*)vd2)) != lValue){
   iCountErrors++;
   Console.WriteLine("Err_94753sdg! Wrong value returned");
   }
   strLoc = "Loc_875esfg";
   lValue = Int64.MaxValue;
   vd1 = &lValue;
   ip1 = new IntPtr(vd1);
   iptr1 = (int*)ip1.ToPointer();
   iCountTestcases++;
   if((*iptr1) != -1){
   iCountErrors++;
   Console.WriteLine("Err_756wrg! Wrong value returned! , " + (*iptr1));
   }
   strLoc = "Loc_008742sf";
   fValue = true;
   vd1 = &fValue;
   ip1 = new IntPtr(vd1);
   iCountTestcases++;
   if((*((Boolean*)ip1.ToPointer())) != fValue){
   iCountErrors++;
   Console.WriteLine("Err_984753sdg! Wrong value returned!");
   }
   strLoc = "Loc_735sdg";
   chValue = 'a';
   vd1 = &chValue;
   ip1 = new IntPtr(vd1);
   iptr1 = (int*)ip1.ToPointer();
   iCountTestcases++;
   if((*((char*)ip1.ToPointer())) != chValue){
   iCountErrors++;
   Console.WriteLine("Err_9745sg! Wrong value returned!");
   }
   strLoc = "Loc_735sdg";
   btValue = 5;
   vd1 = &btValue;
   ip1 = new IntPtr(vd1);
   iCountTestcases++;
//.........这里部分代码省略.........

		internal static string FromUtf8(IntPtr ptr)
		{
			int length = 0;
			unsafe
			{
				byte* p = (byte*) ptr.ToPointer();
				while (*p++ != 0)
					length++;
			}

			return FromUtf8(ptr, length);
		}

 unsafe static void OnCallback(IntPtr handle, int status)
 {
     uv_req_t* uvRequest = (uv_req_t*)handle.ToPointer();
     var request = GCHandle.FromIntPtr(uvRequest->data).Target as DisposeRequest;
     if (request == null)
     {
         Environment.FailFast("invalid callback");
     }
     else
     {
         request._handle.Dispose();
         request.Dispose();
     }
 }

        [System.Security.SecurityCritical]  // auto-generated
        static internal unsafe IntPtr ConvertToNative(string strManaged, IntPtr pNativeBuffer) 
        {
            if (null == strManaged) 
            { 
                return IntPtr.Zero;
            } 
            else
            {
                StubHelpers.CheckStringLength(strManaged.Length);
 
                byte trailByte;
                bool hasTrailByte = strManaged.TryGetTrailByte(out trailByte); 
 
                uint lengthInBytes = (uint)strManaged.Length * 2;
 
                if (hasTrailByte)
                {
                    // this is an odd-sized string with a trailing byte stored in its [....] block
                    lengthInBytes++; 
                }
 
                byte *ptrToFirstChar; 

                if (pNativeBuffer != IntPtr.Zero) 
                {
                    // If caller provided a buffer, construct the BSTR manually. The size
                    // of the buffer must be at least (lengthInBytes + 6) bytes.
#if _DEBUG 
                    uint length = *((uint *)pNativeBuffer.ToPointer());
                    BCLDebug.Assert(length >= lengthInBytes + 6, "BSTR localloc'ed buffer is too small"); 
#endif // _DEBUG 

                    // set length 
                    *((uint *)pNativeBuffer.ToPointer()) = lengthInBytes;

                    ptrToFirstChar = (byte *)pNativeBuffer.ToPointer() + 4;
                } 
                else
                { 
                    // If not provided, allocate the buffer using SysAllocStringByteLen so 
                    // that odd-sized strings will be handled as well.
                    ptrToFirstChar = (byte *)Win32Native.SysAllocStringByteLen(null, lengthInBytes).ToPointer(); 
                }

                // copy characters from the managed string
                fixed (char* ch = strManaged) 
                {
                    Buffer.memcpyimpl( 
                        (byte *)ch, 
                        ptrToFirstChar,
                        (strManaged.Length + 1) * 2); 
                }

                // copy the trail byte if present
                if (hasTrailByte) 
                {
                    ptrToFirstChar[lengthInBytes - 1] = trailByte; 
                } 

                // return ptr to first character 
                return (IntPtr)ptrToFirstChar;
            }
        }