自学教程：C++ GetFileSizeEx函数代码示例

BOOL CHttpRequestSender::CalcAttachmentPartSize(CString sName, LONGLONG& lSize){  lSize = 0;  CString sPartHeader;  BOOL bFormat = FormatAttachmentPartHeader(sName, sPartHeader);  if(!bFormat)    return FALSE;  lSize += sPartHeader.GetLength();  std::map<CString, CHttpRequestFile>::iterator it = m_Request.m_aIncludedFiles.find(sName);  if(it==m_Request.m_aIncludedFiles.end())    return FALSE;   CString sFileName = it->second.m_sSrcFileName.GetBuffer(0);  HANDLE hFile = CreateFile(sFileName,      GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);   if(hFile==INVALID_HANDLE_VALUE)  {        return FALSE;   }  LARGE_INTEGER lFileSize;  BOOL bGetSize = GetFileSizeEx(hFile, &lFileSize);  if(!bGetSize)  {    CloseHandle(hFile);    return FALSE;  }  lSize += lFileSize.QuadPart;  CloseHandle(hFile);  CString sPartFooter;  bFormat = FormatAttachmentPartFooter(sName, sPartFooter);  if(!bFormat)    return FALSE;  lSize += sPartFooter.GetLength();  return TRUE;}

LONG64 CCrashInfoReader::GetUncompressedReportSize(CErrorReportInfo& eri){	// Calculate summary size of all files included into crash report    LONG64 lTotalSize = 0;    std::map<CString, ERIFileItem>::iterator it;    HANDLE hFile = INVALID_HANDLE_VALUE;      CString sMsg;    BOOL bGetSize = FALSE;    LARGE_INTEGER lFileSize;	// Walk through all files in the crash report    for(it=eri.m_FileItems.begin(); it!=eri.m_FileItems.end(); it++)    {   		// Get file name        CString sFileName = it->second.m_sSrcFile.GetBuffer(0);		// Check file exists        hFile = CreateFile(sFileName,             GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);         if(hFile==INVALID_HANDLE_VALUE)            continue; // File does not exist		// Get file size        bGetSize = GetFileSizeEx(hFile, &lFileSize);        if(!bGetSize)        {            CloseHandle(hFile);            continue;        }		// Add to the sum        lTotalSize += lFileSize.QuadPart;		// Clean up        CloseHandle(hFile);        hFile = INVALID_HANDLE_VALUE;    }	// Return summary size    return lTotalSize;}

static int DOKAN_CALLBACKMirrorSetAllocationSize(	LPCWSTR				FileName,	LONGLONG			AllocSize,	PDOKAN_FILE_INFO	DokanFileInfo){	WCHAR			filePath[MAX_PATH];	HANDLE			handle;	LARGE_INTEGER	fileSize;	GetFilePath(filePath, MAX_PATH, FileName);	DbgPrint(L"SetAllocationSize %s, %I64d/n", filePath, AllocSize);	handle = (HANDLE)DokanFileInfo->Context;	if (!handle || handle == INVALID_HANDLE_VALUE) {		DbgPrint(L"/tinvalid handle/n/n");		return -1;	}	if (GetFileSizeEx(handle, &fileSize)) {		if (AllocSize < fileSize.QuadPart) {			fileSize.QuadPart = AllocSize;			if (!SetFilePointerEx(handle, fileSize, NULL, FILE_BEGIN)) {				DbgPrint(L"/tSetAllocationSize: SetFilePointer eror: %d, "					L"offset = %I64d/n/n", GetLastError(), AllocSize);				return GetLastError() * -1;			}			if (!SetEndOfFile(handle)) {				DWORD error = GetLastError();				DbgPrint(L"/terror code = %d/n/n", error);				return error * -1;			}		}	} else {		DWORD error = GetLastError();		DbgPrint(L"/terror code = %d/n/n", error);		return error * -1;	}	return 0;}

DWORD FindProcessId (DWORD jobNumber)/* Obtain the process ID of the specified job number. */{	HANDLE hJobData;	JM_JOB jobRecord;	DWORD nXfer, fileSizeLow;	TCHAR jobMgtFileName[MAX_PATH+1];	OVERLAPPED regionStart;	LARGE_INTEGER fileSize;	if ( !GetJobMgtFileName (jobMgtFileName) ) return 0;	hJobData = CreateFile (jobMgtFileName, GENERIC_READ,			FILE_SHARE_READ | FILE_SHARE_WRITE,			NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);	if (hJobData == INVALID_HANDLE_VALUE) return 0;	/* Position to the correct record, but not past the end of file */	/* As a variation, use GetFileSize to demonstrate its operation. */	if (!GetFileSizeEx (hJobData, &fileSize) ||		(fileSize.HighPart != 0 || SJM_JOB * (jobNumber - 1) > fileSize.LowPart 		 || fileSize.LowPart > SJM_JOB * MAX_JOBS_ALLOWED))			return 0;	fileSizeLow = fileSize.LowPart;	/* SetFilePoiner is more convenient here than SetFilePointerEx since the the file is known to be "short" ( < 4 GB). */	SetFilePointer (hJobData, SJM_JOB * (jobNumber - 1), NULL, FILE_BEGIN);		/* Get a shared lock on the record. */		regionStart.Offset = SJM_JOB * (jobNumber - 1);	regionStart.OffsetHigh = 0; /* Assume a "short" file. */	regionStart.hEvent = (HANDLE)0;	LockFileEx (hJobData, 0, 0, SJM_JOB, 0, &regionStart);		if (!ReadFile (hJobData, &jobRecord, SJM_JOB, &nXfer, NULL))		ReportError (_T ("JobData file error"), 0, TRUE);	UnlockFileEx (hJobData, 0, SJM_JOB, 0, &regionStart);	CloseHandle (hJobData);	return jobRecord.ProcessId;}

static int_zip_stat_win32(HANDLE h, zip_stat_t *st, _zip_source_win32_read_file_t *ctx){    FILETIME mtimeft;    time_t mtime;    LARGE_INTEGER size;    int regularp;    if (!GetFileTime(h, NULL, NULL, &mtimeft)) {	zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));	return -1;    }    if (_zip_filetime_to_time_t(mtimeft, &mtime) < 0) {	zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);	return -1;    }    regularp = 0;    if (GetFileType(h) == FILE_TYPE_DISK) {	regularp = 1;    }    if (!GetFileSizeEx(h, &size)) {	zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));	return -1;    }    zip_stat_init(st);    st->mtime = mtime;    st->valid |= ZIP_STAT_MTIME;    if (ctx->end != 0) {	st->size = ctx->end - ctx->start;	st->valid |= ZIP_STAT_SIZE;    }    else if (regularp) {	st->size = (zip_uint64_t)size.QuadPart;	st->valid |= ZIP_STAT_SIZE;    }    return 0;}

int uGetFileSize(UFile fd, __int64 * file_size, sys_call_error_fun fun){#ifdef _WIN32    LARGE_INTEGER size;    BOOL res = GetFileSizeEx(fd, &size);    if (res == 0)        sys_call_error("GetFileSizeEx");    else        *file_size = size.QuadPart;    return res;#else    struct stat64 buf;    if (fstat64(fd, &buf) == -1)    {        sys_call_error("fstat64");        return 0;    }    *file_size = buf.st_size;    return 1;#endif}

::FLAC__StreamDecoderLengthStatusOurDecoder::length_callback(FLAC__uint64 *stream_length){#ifdef PRWIN_ENV	LARGE_INTEGER lpos;	BOOL result = GetFileSizeEx(_fp, &lpos);		*stream_length = lpos.QuadPart;		return (result ? FLAC__STREAM_DECODER_LENGTH_STATUS_OK : FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR);#else	SInt64 fork_size = 0;		OSErr result = FSGetForkSize(CAST_REFNUM(_fp), &fork_size);			*stream_length = fork_size;		return (result == noErr ? FLAC__STREAM_DECODER_LENGTH_STATUS_OK : FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR);#endif}

LONGLONG getFileSize(HANDLE hFile){	LARGE_INTEGER lpFileSize = {0};	if ((hFile != INVALID_HANDLE_VALUE) && (hFile != 0))	{		if (!GetFileSizeEx(hFile, &lpFileSize))		{			MessageBox(0, TEXT("GetFileSizeEx failed"), TEXT("Error"), MB_ICONERROR);			return 0;		}		else		{			return lpFileSize.QuadPart;		}	}	else	{		return 0;	}}

size_t File::GetFileSize(){	if( !IsValidHandle() )		return 0;	size_t Size = 0;#if _WIN32 || _WIN64	LARGE_INTEGER LInt;	Memory::Memzero( &LInt, sizeof(LInt) );	GetFileSizeEx( m_file_handle, &LInt );	Size = (size_t) LInt.QuadPart;	//DWORD dwSize = GetFileSize( m_hFile, NULL );#else	size_t Pos = ftell(m_file_handle);	fseek( m_file_handle, 0, SEEK_END );	Size = ftell(m_file_handle);	fseek( m_file_handle, Pos, SEEK_SET );#endif	return Size;}

BOOL CFileMemoryMapping::Init(LPCTSTR szFileName){    if(m_hFile!=INVALID_HANDLE_VALUE)    {        // If a file mapping already created, destroy it        Destroy();    }    // Open file handle    m_hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);    if(m_hFile == INVALID_HANDLE_VALUE)        return FALSE;    // Create file mapping    m_hFileMapping = CreateFileMapping(m_hFile, 0, PAGE_READONLY, 0, 0, 0);    LARGE_INTEGER size;    GetFileSizeEx(m_hFile, &size);    m_uFileLength = size.QuadPart;    return TRUE;}

//Return the contents of a text filevoid LoadFile(char *path, DataFile *dataFile){		HANDLE fileHandle = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);	if (fileHandle != INVALID_HANDLE_VALUE)	{		LARGE_INTEGER fileSize;		if (GetFileSizeEx(fileHandle, &fileSize))		{			unsigned int fileSize_32bit = (unsigned int)fileSize.QuadPart;			dataFile->Data = VirtualAlloc(0, fileSize_32bit, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);						if (dataFile->Data)			{				DWORD bytesRead;				if (ReadFile(fileHandle, dataFile->Data, fileSize_32bit, &bytesRead, NULL) && fileSize_32bit == bytesRead)				{					dataFile->Length = fileSize_32bit;				}				else				{					//Failed to read file				}			}			else			{				//Failed to allocate memory			}		}		else		{			//Failed to get file size		}	}	else	{		//Failed to create file handle	}}

/* return the size of a given file in '*psize'. returns 0 on * success, -1 on failure (error code in errno) */APosixStatuspath_get_size( const char*  path, uint64_t  *psize ){#ifdef _WIN32    /* avoid _stat64 which is only defined in MSVCRT.DLL, not CRTDLL.DLL */    /* do not use OpenFile() because it has strange search behaviour that could */    /* result in getting the size of a different file */    LARGE_INTEGER  size;    HANDLE  file = CreateFile( /* lpFilename */        path,                               /* dwDesiredAccess */   GENERIC_READ,                               /* dwSharedMode */     FILE_SHARE_READ|FILE_SHARE_WRITE,                               /* lpSecurityAttributes */  NULL,                               /* dwCreationDisposition */ OPEN_EXISTING,                               /* dwFlagsAndAttributes */  0,                               /* hTemplateFile */      NULL );    if (file == INVALID_HANDLE_VALUE) {        /* ok, just to play fair */        errno = ENOENT;        return -1;    }    if (!GetFileSizeEx(file, &size)) {        /* maybe we tried to get the size of a pipe or something like that ? */        *psize = 0;    }    else {        *psize = (uint64_t) size.QuadPart;    }    CloseHandle(file);    return 0;#else    int    ret;    struct stat  st;    CHECKED(ret, stat(path, &st));    if (ret == 0) {        *psize = (uint64_t) st.st_size;    }    return ret;#endif}

LWS_VISIBLE lws_fop_fd_t_lws_plat_file_open(const struct lws_plat_file_ops *fops, const char *filename,		    const char *vpath, lws_fop_flags_t *flags){	HANDLE ret;	WCHAR buf[MAX_PATH];	lws_fop_fd_t fop_fd;	LARGE_INTEGER llFileSize = {0};	MultiByteToWideChar(CP_UTF8, 0, filename, -1, buf, ARRAY_SIZE(buf));	if (((*flags) & 7) == _O_RDONLY) {		ret = CreateFileW(buf, GENERIC_READ, FILE_SHARE_READ,			  NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);	} else {		ret = CreateFileW(buf, GENERIC_WRITE, 0, NULL,			  CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);	}	if (ret == LWS_INVALID_FILE)		goto bail;	fop_fd = malloc(sizeof(*fop_fd));	if (!fop_fd)		goto bail;	fop_fd->fops = fops;	fop_fd->fd = ret;	fop_fd->filesystem_priv = NULL; /* we don't use it */	fop_fd->flags = *flags;	fop_fd->len = GetFileSize(ret, NULL);	if(GetFileSizeEx(ret, &llFileSize))		fop_fd->len = llFileSize.QuadPart;	fop_fd->pos = 0;	return fop_fd;bail:	return NULL;}

bool LWOFile::LoadFromFile(const char *strFile){  // try to open file  HANDLE hFile=CreateFileA(strFile, GENERIC_READ, FILE_SHARE_READ, NULL,                          OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);  if(hFile==INVALID_HANDLE_VALUE)  {    AddError("Could not open file: " + std::string(strFile));    return false;  }  // get file size  LARGE_INTEGER LI_Size;  if(!GetFileSizeEx(hFile,&LI_Size))  {    AddError("Could not get file size!");    return false;  }  unsigned int iFileSize=(unsigned int)LI_Size.QuadPart;  // allocate memory to hold the file  char *pData=new char[iFileSize];  // read file to memory  DWORD iBytesRead=0;  if(!ReadFile(hFile,pData,iFileSize,&iBytesRead,NULL) || iBytesRead!=iFileSize)  {    AddError("Reading file failed!");    delete[] pData;    CloseHandle(hFile);    return false;  }  // load  if(!LoadFromMemory(pData, iFileSize)) return false;  delete[] pData;  CloseHandle(hFile);  return true;}

BOOL kull_m_file_readData(PCWCHAR fileName, PBYTE * data, PDWORD lenght)	// for little files !{	BOOL reussite = FALSE;	DWORD dwBytesReaded;	LARGE_INTEGER filesize;	HANDLE hFile = CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);	if(hFile && hFile != INVALID_HANDLE_VALUE)	{		if(GetFileSizeEx(hFile, &filesize) && !filesize.HighPart)		{			*lenght = filesize.LowPart;			if(*data = (PBYTE) LocalAlloc(LPTR, *lenght))			{				if(!(reussite = ReadFile(hFile, *data, *lenght, &dwBytesReaded, NULL) && (*lenght == dwBytesReaded)))					LocalFree(*data);			}		}		CloseHandle(hFile);	}	return reussite;}

static HRESULT open_file(FileProtocol *This, const WCHAR *path, IInternetProtocolSink *protocol_sink){    LARGE_INTEGER size;    HANDLE file;    file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL,            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);    if(file == INVALID_HANDLE_VALUE)        return report_result(protocol_sink, INET_E_RESOURCE_NOT_FOUND, GetLastError());    if(!GetFileSizeEx(file, &size)) {        CloseHandle(file);        return report_result(protocol_sink, INET_E_RESOURCE_NOT_FOUND, GetLastError());    }    This->file = file;    This->size = size.u.LowPart;    IInternetProtocolSink_ReportProgress(protocol_sink,            BINDSTATUS_CACHEFILENAMEAVAILABLE, path);    return S_OK;}

uint64 MFFileNative_GetSize(const char *pFilename){	MFCALLSTACK;	uint64 fileSize = 0;#if defined(MF_XBOX) || defined(MF_X360)	pFilename = FixXBoxFilename(pFilename);#endif	HANDLE hFile = CreateFile(MFString_UFT8AsWChar(pFilename), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, NULL, NULL);	if(hFile != INVALID_HANDLE_VALUE)	{		LARGE_INTEGER size;		GetFileSizeEx(hFile, &size);		CloseHandle(hFile);		fileSize = size.QuadPart;	}	return fileSize;}

u64 fs::file::size() const{	g_tls_error = fse::ok;#ifdef _WIN32	LARGE_INTEGER size;	if (!GetFileSizeEx((HANDLE)m_fd, &size))	{		return -1;	}	return size.QuadPart;#else	struct stat file_info;	if (::fstat(m_fd, &file_info) < 0)	{		return -1;	}	return file_info.st_size;#endif}

UINT64  CHttpDownloader::isBreakPointFile(std::wstring wcsFile){	UINT64 uI64Num =0;	wchar_t wcsNum[255];	UINT64  uI64Return =0 ;	LARGE_INTEGER largeSize;	largeSize.QuadPart = 0;	DWORD   dwRegType = 0, dwReturnSize = sizeof(wcsNum); 	HANDLE hFile = CreateFile(wcsFile.c_str(),MYWIRTEFILE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);	if( hFile != INVALID_HANDLE_VALUE)		{		GetFileSizeEx(hFile,&largeSize);		uI64Num = largeSize.QuadPart;		if( uI64Num > BREAKRETURNBACKBYTE*1024 )			uI64Return = uI64Num - BREAKRETURNBACKBYTE*1024;	}	CloseHandle(hFile);	return uI64Return;}

VOIDWriteDebugLog(LPSTR lpFile, UINT iLine, LPSTR lpFunc, LPWSTR lpMsg, ...){    LARGE_INTEGER FileSize, MoveTo, NewPos;    WCHAR szMsg[MAX_STR_LEN * 3];    WCHAR szText[MAX_STR_LEN * 4], szTime[MAX_STR_LEN];    DWORD dwBytesWritten;    va_list args;    if (!hDebugLog || hDebugLog == INVALID_HANDLE_VALUE)        return;    MoveTo.QuadPart = 0;    if (!SetFilePointerEx(hDebugLog, MoveTo, &NewPos, FILE_END))        return;    if (!GetFileSizeEx(hDebugLog, &FileSize))        return;    LockFile(hDebugLog, (DWORD_PTR)NewPos.QuadPart, 0, (DWORD_PTR)FileSize.QuadPart, 0);    GetTimeFormat(LOCALE_USER_DEFAULT,                  0, NULL, NULL, szTime,                  MAX_STR_LEN);    va_start(args, lpMsg);    StringCbVPrintf(szMsg, sizeof(szMsg), lpMsg, args);    va_end(args);    StringCbPrintf(szText, sizeof(szText),                   L"[%s] %S:%ld %S(): /"%s/"/r/n",                   szTime, lpFile, iLine, lpFunc, szMsg);    WriteFile(hDebugLog, szText,              wcslen(szText) * sizeof(WCHAR),              &dwBytesWritten, NULL);    UnlockFile(hDebugLog, (DWORD_PTR)NewPos.QuadPart, 0, (DWORD_PTR)FileSize.QuadPart, 0);}

static int64_t ALMIXER_CALLwindows_file_size(ALmixer_RWops * context){    LARGE_INTEGER size;    if (!context || context->hidden.windowsio.h == INVALID_HANDLE_VALUE) {        ALmixer_SetError("windows_file_size: invalid context/file not opened");		return -1;	}    if (!GetFileSizeEx(context->hidden.windowsio.h, &size)) {#if 1        return WIN_SetError("windows_file_size");#else		/* There are a lot of dependencies on iconv/UTF16 stuff just for WIN_SetError to print the HRESULT. I'd rather avoid it */		ALmixer_SetError("windows_file_size failed calling GetFileSizeEx()");		return -1;#endif    }    return size.QuadPart;}

bool ReadFile(String filename, JavaScript::Object options, String& result){	String encoding = TEXT("");	if (options->HasKey("encoding"))		options->GetString("encoding");	// text file	if (encoding == TEXT("") || encoding == TEXT("utf-8") || encoding == TEXT("text/plain;utf-8"))	{		HANDLE hFile = CreateFile(filename.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);		if (hFile != INVALID_HANDLE_VALUE)		{			DWORD numBytesRead = 0;			LARGE_INTEGER fileSize;			GetFileSizeEx(hFile, &fileSize);			// we don't want to read too large files			_ASSERT(fileSize.HighPart == 0);			// allocate buffer and read file			BYTE* data = new BYTE[fileSize.LowPart];			::ReadFile(hFile, (LPVOID) data, (DWORD) fileSize.LowPart, &numBytesRead, NULL);			// convert the buffer			int wcLen = MultiByteToWideChar(CP_UTF8, 0, (LPCCH) data, numBytesRead, NULL, 0);			TCHAR* buf = new TCHAR[wcLen + 1];			MultiByteToWideChar(CP_UTF8, 0, (LPCCH) data, numBytesRead, buf, wcLen);			buf[wcLen] = 0;			result = String(buf, buf + wcLen);			delete[] buf;			delete[] data;		}		CloseHandle(hFile);		return true;	}	return false;}

uint64 TFile::GetSize(const TStr& FNm) {    // open     HANDLE hFile = CreateFile(       FNm.CStr(),            // file to open       GENERIC_READ,          // open for reading       FILE_SHARE_READ | FILE_SHARE_WRITE,       // share for reading       NULL,                  // default security       OPEN_EXISTING,         // existing file only       FILE_ATTRIBUTE_NORMAL, // normal file       NULL);                 // no attr. template    // check if we could open it    if (hFile == INVALID_HANDLE_VALUE) {        TExcept::Throw("Can not open file " + FNm + "!"); }    // read file times    LARGE_INTEGER lpFileSizeHigh;	if (!GetFileSizeEx(hFile, &lpFileSizeHigh)) {        TExcept::Throw("Can not read size of file " + FNm + "!"); }    // close file    CloseHandle(hFile);    // convert to uint64	return uint64(lpFileSizeHigh.QuadPart);}

Win32FileContents ReadEntireFile(const char * Filename){	HANDLE File = CreateFileA(Filename, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);	LARGE_INTEGER Size;	GetFileSizeEx(File, &Size);	Win32FileContents FileContents = {};	FileContents.Size = Size.QuadPart;	FileContents.Data = (unsigned char *)VirtualAlloc(0, Size.LowPart, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);	DWORD BytesRead;	ReadFile(File, FileContents.Data, Size.LowPart, &BytesRead, 0);	if (BytesRead != Size.LowPart) {		DisplayMessage(GetLastError());		//TODO: Logging, errors etc	}	return FileContents;};

/**	获得只读文件的句柄。注意只适合于只读文件！ *	快速访问文件，用FileMapping方式对大文件的访问 *	将会最为快捷。 *	顺序访问数据 */FILEMAPHANDLE FileMapOpen(const TCHAR *file_name){    FILEMAPHANDLE handle;    handle = (FILEMAPHANDLE) malloc(sizeof(FILEMAPDATA));    if (!handle)        return 0;    //打开文件    handle->h_file = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);    if (handle->h_file == INVALID_HANDLE_VALUE)    {        free(handle);        return 0;    }    handle->length = 0;    GetFileSizeEx(handle->h_file, (PLARGE_INTEGER)&handle->length);    //创建映射    handle->h_map = CreateFileMapping(handle->h_file, 0, PAGE_READONLY,	0, 0, 0);    if (!handle->h_map)    {        CloseHandle(handle->h_file);        free(handle);        return 0;    }    SYSTEM_INFO sys_info;    GetSystemInfo(&sys_info);    handle->granularity = (int)sys_info.dwAllocationGranularity;    handle->offset		= 0;    handle->view		= 0;    return handle;}

void MetroWindow::DiscoverInstallerImage(){	wchar_t szImageFile[MAX_UNC_PATH] = { 0 };	if (DiscoverInstallerIMAGE(m_hWnd, szImageFile) == S_OK)	{		::SetWindowText(GetDlgItem(IDC_EDIT_IMAGE), szImageFile);		ProcessInfo = L"Manager Task Rate:";		JobStatusRate = L"Task not start";		MTNotices = L"Notices> Enviroment Inspection:/n"+envinfo;		m_proge.SetPos(0);		HANDLE hFile;		LARGE_INTEGER FileSize;		hFile = CreateFileW(szImageFile, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);		if (hFile != INVALID_HANDLE_VALUE)		{			GetFileSizeEx(hFile, &FileSize);			swprintf_s(SizeStr, L" %lld Bytes ||%4.1f KB ||%4.2f MB ||%4.2f GB", FileSize.QuadPart, (float)FileSize.QuadPart / 1024, (float)FileSize.QuadPart / (1024 * 1024), (float)FileSize.QuadPart / (1024 * 1024 * 1024));			SendMessage(WM_PAINT, 0, 0);		}		CloseHandle(hFile);	}}

HRESULT MkvFile::Open(const wchar_t* strFileName){    if (strFileName == 0)        return E_INVALIDARG;    if (m_hFile != INVALID_HANDLE_VALUE)        return E_UNEXPECTED;    m_hFile = CreateFile(                strFileName,                GENERIC_READ,                FILE_SHARE_READ,                0,  //security attributes                OPEN_EXISTING,                FILE_ATTRIBUTE_READONLY,                0);    if (m_hFile == INVALID_HANDLE_VALUE)    {        const DWORD e = GetLastError();        return HRESULT_FROM_WIN32(e);    }    LARGE_INTEGER size;    const BOOL b = GetFileSizeEx(m_hFile, &size);    if (!b)    {        const DWORD e = GetLastError();        Close();        return HRESULT_FROM_WIN32(e);    }    m_length = size.QuadPart;    assert(m_length >= 0);    return S_OK;}

void* ReadWholeFile( char* filename, int64* bytesRead ) {	//Open	HANDLE fileHandle;	//TODO: look into other options, such as: Overlapped, No_Bufffering, and Random_Access	fileHandle = CreateFile( filename, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0 );	if( fileHandle == INVALID_HANDLE_VALUE ) {		assert( false );	}	//Determine amount of data	LARGE_INTEGER fileSize;	GetFileSizeEx( fileHandle, &fileSize );	if( fileSize.QuadPart == 0 ) {		assert( false );	}	assert( fileSize.QuadPart <= 0xFFFFFFFF );	//Reserve Space	void* data = 0;	data = malloc( fileSize.QuadPart );	memset( data, 0, fileSize.QuadPart );	assert( data != 0 );	//Read data	DWORD dataRead = 0;	//TODO: adjust for overlapped or async stuff?	BOOL readSuccess = ReadFile( fileHandle, data, fileSize.QuadPart, &dataRead, 0 );	if( !readSuccess || dataRead != fileSize.QuadPart ) {	}	//Close	BOOL closeReturnValue = CloseHandle( fileHandle );	assert( closeReturnValue );	*bytesRead = fileSize.QuadPart;	return data;}

static int _file_load(const char *file, void **data, u32 * len){    HANDLE h, fmo;    LARGE_INTEGER size;    void *buf;    h = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);    if (h == INVALID_HANDLE_VALUE) {        fprintf(stderr, "ERROR: failed to open file %s/n", file);        return -1;    }    // figure out how big the file is.    if (GetFileSizeEx(h, &size) == 0) {        fprintf(stderr, "ERROR: failed to get size of file %s/n", file);        return -1;    }    fmo = CreateFileMapping(h, NULL, PAGE_READONLY, size.u.HighPart, size.u.LowPart, NULL);    if (fmo == NULL) {        fprintf(stderr, "ERROR: failed to create file mapping for file %s: %d/n", file, GetLastError());        return -1;    }    buf = MapViewOfFile(fmo, FILE_MAP_READ, 0, 0, size.u.LowPart);    if (buf == NULL) {        fprintf(stderr, "ERROR: failed to create a file view for file %s: %d/n", file, GetLastError());        return -1;    }    printf("file %s (size=%ld) mapped at %p/n", file,           size.u.LowPart, buf);    *data = buf;    *len = size.u.LowPart;    return 0;}

size_t get_filesize(const char *filepath){#ifdef WINDOWS    HANDLE hFile = CreateFile(		filepath, 		GENERIC_READ, 		FILE_SHARE_READ | FILE_SHARE_WRITE, 		NULL, 		OPEN_EXISTING, 		FILE_ATTRIBUTE_NORMAL, 		NULL	);		    if (hFile == INVALID_HANDLE_VALUE)        return 0;    LARGE_INTEGER size;    if (!GetFileSizeEx(hFile, &size))    {        CloseHandle(hFile);        return 0;    }    CloseHandle(hFile);	    return (size_t)size.QuadPart;#else	size_t size = 0;	struct stat fileStat;		if ((stat(filepath, &fileStat)) >= 0)	{		size = (size_t)fileStat.st_size;	}		return size;#endif}