C# IntPtr.ToInt64方法代码示例

 private byte* Align(IntPtr buf, uint alignTo)
 {
     //This makes an aligned buffer linux needs this.
     //The buffer must originally be at least one alignment bigger!
     var diff = alignTo - (buf.ToInt64() % alignTo);
     var aligned = (IntPtr)(buf.ToInt64() + diff);
     return (byte*)aligned;
 }

        public SharedMemory(string name, IntPtr size)
        {
            mmf = MemoryMappedFile.OpenExisting(name + "_CONNECT_DATA");

            mmva = mmf.CreateViewAccessor();
            if (mmf.SafeMemoryMappedFileHandle.IsInvalid)
                throw new MySqlException("Cannot open file mapping " + name);
            mmvs = mmf.CreateViewStream(0L, size.ToInt64());
            mmva = mmf.CreateViewAccessor(0L, size.ToInt64());
        }

 static IntPtr GetReadSize(IntPtr pointer, IntPtr endPointer, int bufferSize)
 {
     if (endPointer.ToInt64() < IntPtr.Add(pointer, bufferSize).ToInt64())
     {
         return (IntPtr)(endPointer.ToInt64() - pointer.ToInt64());
     }
     else
     {
         return new IntPtr(bufferSize);
     }
 }

        /// <summary>
        /// Read a hardware independent dictionary of language and code page identifier tables.
        /// </summary>
        /// <param name="lpRes">Pointer to the beginning of data.</param>
        /// <returns>Pointer to the end of data.</returns>
        internal override IntPtr Read(IntPtr lpRes)
        {
            _vars.Clear();
            IntPtr pChild = base.Read(lpRes);

            while (pChild.ToInt64() < (lpRes.ToInt64() + _header.wLength))
            {
                VarTable res = new VarTable(pChild);
                _vars.Add(res.Key, res);
                pChild = ResourceUtil.Align(pChild.ToInt64() + res.Header.wLength);
            }

            return new IntPtr(lpRes.ToInt64() + _header.wLength);
        }

        /// <summary>
        /// Read a table of language and code page identifier pairs.
        /// </summary>
        /// <param name="lpRes">Pointer to the beginning of the data.</param>
        /// <returns></returns>
        internal override IntPtr Read(IntPtr lpRes)
        {
            _languages.Clear();
            IntPtr pVar = base.Read(lpRes);

            while (pVar.ToInt64() < (lpRes.ToInt64() + _header.wLength))
            {
                Kernel32.VAR_HEADER var = (Kernel32.VAR_HEADER) Marshal.PtrToStructure(
                    pVar, typeof(Kernel32.VAR_HEADER));
                _languages.Add(var.wLanguageIDMS, var.wCodePageIBM);
                pVar = new IntPtr(pVar.ToInt64() + Marshal.SizeOf(var));
            }

            return new IntPtr(lpRes.ToInt64() + _header.wLength);
        }

 /// <summary> Constructs a stream that marshals bytes from unmanaged memory </summary>
 public MarshallingStream(IntPtr ptrBytes, bool readOnly, int start, int length)
 {
     _ptrBytes = start == 0 ? ptrBytes : new IntPtr(ptrBytes.ToInt64() + start);
     _readOnly = readOnly;
     _length = length;
     _position = 0;
 }

        /// <summary>
        /// Read the accelerator.
        /// </summary>
        /// <param name="lpRes">Address in memory.</param>
        internal IntPtr Read(IntPtr lpRes)
        {
            _accel = (User32.ACCEL) Marshal.PtrToStructure(
                lpRes, typeof(User32.ACCEL));

            return new IntPtr(lpRes.ToInt64() + Marshal.SizeOf(_accel));
        }

        public static UInt32 NtWriteFile(
            IntPtr FileHandle,
            IntPtr Event,
            IntPtr ApcRoutine,
            IntPtr ApcContext,
            IntPtr IoStatusBlock,
            IntPtr Buffer,
            UInt32 Length,
            UInt32 ByteOffset,
            UInt32 Key)
        {
            if (DetourBlock.IsDetouring) {
                return OriginalFn(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock,
                    Buffer, Length, ByteOffset, Key);
            }

            using (var block = new DetourBlock())
            {
                var result = OriginalFn(FileHandle, Event, ApcRoutine, ApcContext, IoStatusBlock,
                    Buffer, Length, ByteOffset, Key);

                if (result == 0 /* STATUS_SUCCESS */)
                {
                    Remoting.Scribe.DocumentFileWrite(Process.GetCurrentProcess().Id, FileHandle.ToInt64());
                }

                return result;
            }
        }

 /// <summary>
 ///     Assemble the specified assembly code at a base address.
 /// </summary>
 /// <param name="asm">The assembly code.</param>
 /// <param name="baseAddress">The address where the code is rebased.</param>
 /// <returns>An array of bytes containing the assembly code.</returns>
 public byte[] Assemble(string asm, IntPtr baseAddress)
 {
     // Rebase the code
     asm = $"use32\norg 0x{baseAddress.ToInt64():X8}\n" + asm;
     // Assemble and return the code
     return FasmNet.Assemble(asm);
 }

		internal static IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
		{
			if (msg != CUSTOM_MESSAGE) {
				return IntPtr.Zero;
			}
			handled = true;
			long fileNumber = wParam.ToInt64();
			long openEvenIfProjectIsOpened = lParam.ToInt64();
			LoggingService.Info("Receiving custom message...");
			if (openEvenIfProjectIsOpened == 0 && ProjectService.OpenSolution != null) {
				return new IntPtr(RESULT_PROJECT_IS_OPEN);
			} else {
				try {
					WorkbenchSingleton.SafeThreadAsyncCall(
						delegate { NativeMethods.SetForegroundWindow(WorkbenchSingleton.MainWin32Window.Handle) ; }
					);
					string tempFileName = Path.Combine(Path.GetTempPath(), "sd" + fileNumber + ".tmp");
					foreach (string file in File.ReadAllLines(tempFileName)) {
						WorkbenchSingleton.SafeThreadAsyncCall(
							delegate(string openFileName) { FileService.OpenFile(openFileName); }
							, file
						);
					}
				} catch (Exception ex) {
					LoggingService.Warn(ex);
				}
				return new IntPtr(RESULT_FILES_HANDLED);
			}
		}

		static void Initialize (IntPtr ptr, IntPtr data)
		{
			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
			GFileDescriptorBasedIface native_iface = (GFileDescriptorBasedIface) Marshal.PtrToStructure (ifaceptr, typeof (GFileDescriptorBasedIface));
			native_iface.GetFd = iface.GetFd;
			Marshal.StructureToPtr (native_iface, ifaceptr, false);
		}

        /// <summary>
        ///     Constructor for WLAN_INTERFACE_INFO_LIST.
        ///     Constructor is needed because the InterfaceInfo member varies based on how many adapters are in the system.
        /// </summary>
        /// <param name="pointerToWlanInterfaceInfoList">the unmanaged pointer containing the list.</param>
        public WLAN_INTERFACE_INFO_LIST(IntPtr pointerToWlanInterfaceInfoList)
        {
            // The first 4 bytes are the number of WLAN_INTERFACE_INFO structures.
            this.dwNumberOfItems = Marshal.ReadInt32(pointerToWlanInterfaceInfoList, (0 * Marshal.SizeOf(typeof(int))));

            // The next 4 bytes are the index of the current item in the unmanaged API.
            this.dwIndex = Marshal.ReadInt32(pointerToWlanInterfaceInfoList, (1 * Marshal.SizeOf(typeof(int))));

            // Construct the array of WLAN_INTERFACE_INFO structures.
            this.InterfaceInfo = new WLAN_INTERFACE_INFO[this.dwNumberOfItems];

            // start pointer
            long start = pointerToWlanInterfaceInfoList.ToInt64() + (2 * Marshal.SizeOf(typeof(int))); // we skip 8 for the first and second int in the structure

            // get the size of WLAN_INTERFACE_INFO
            int sizeOfWlanInterfaceInfo = Marshal.SizeOf(typeof (WLAN_INTERFACE_INFO));

            // we know there are dwNumberOfItems in the struct
            // so we can take each of those memory pieces and marshal them to WLAN_INTERFACE_INFO

            for (int i = 0; i <= this.dwNumberOfItems - 1; i++)
            {
                var pItemList = new IntPtr(start + (i * sizeOfWlanInterfaceInfo));

                this.InterfaceInfo[i] = (WLAN_INTERFACE_INFO) Marshal.PtrToStructure(pItemList, typeof (WLAN_INTERFACE_INFO));
            }
        }

 private static byte[] IntPtrToBytes(IntPtr p, long offset, long length)
 {
     byte[] buffer = new byte[0x10 + IntPtr.Size];
     for (int i = 0; i < 8; i++)
     {
         buffer[i] = (byte) ((offset >> (8 * i)) & 0xffL);
     }
     for (int j = 0; j < 8; j++)
     {
         buffer[8 + j] = (byte) ((length >> (8 * j)) & 0xffL);
     }
     if (IntPtr.Size == 4)
     {
         int num3 = p.ToInt32();
         for (int m = 0; m < 4; m++)
         {
             buffer[0x10 + m] = (byte) ((num3 >> (8 * m)) & 0xff);
         }
         return buffer;
     }
     long num5 = p.ToInt64();
     for (int k = 0; k < 8; k++)
     {
         buffer[0x10 + k] = (byte) ((num5 >> (8 * k)) & 0xffL);
     }
     return buffer;
 }

 public static PyType? GetEveObjectType(IntPtr intptr, bool isDerived = false)
 {
     PyType? returnType;
     if (!_pythontypesLoaded)
     {
         PopulatePythonTypes();
     }
     if (intptr == IntPtr.Zero)
     {
         return PyType.Invalid;
     }
     IntPtr key = Marshal.ReadIntPtr(((IntPtr)intptr.ToInt64() + 4)); // Points to the type
     if (!_pythonTypes.TryGetValue(key, out returnType) && !isDerived)
     {
         returnType = GetEveObjectType(key, true);
         _pythonTypes.Add(key, returnType);
         return returnType;
     }
     if (isDerived)
     {
         string str = returnType.ToString();
         returnType = (PyType)Enum.Parse(typeof(PyType), "Derived" + str);
     }
     return returnType;
 }

		static void Initialize (IntPtr ptr, IntPtr data)
		{
			IntPtr ifaceptr = new IntPtr (ptr.ToInt64 () + class_offset);
			AtkHyperlinkImplIface native_iface = (AtkHyperlinkImplIface) Marshal.PtrToStructure (ifaceptr, typeof (AtkHyperlinkImplIface));
			native_iface.GetHyperlink = iface.GetHyperlink;
			Marshal.StructureToPtr (native_iface, ifaceptr, false);
		}