2014-08-08 一期笔记

最新推荐文章于 2023-11-29 07:50:19 发布
最新推荐文章于 2023-11-29 07:50:19 发布
阅读量369 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/remington2/article/details/38440909
版权

#include "StdAfx.h"
#include "LjlFile.h"
#include <ShellAPI.h>
#include <io.h>
#include <vector>

CLjlFile::CLjlFile(void)
{
 flag=0;
}

CLjlFile::~CLjlFile(void)
{
}


/*!< 递归删除非空目录 */
void CLjlFile::delDirectory(CString strDir)
{
 if(strDir.IsEmpty())
 {
  return;
 }

 /*!< 首先删除文件及子文件夹 */
 CFileFind finder;

 BOOL bFound = finder.FindFile(strDir + L"\\*", 0);
 while(bFound)
 {
  bFound = finder.FindNextFile();
  if(finder.IsDots()) /*!< 是"."或".." */
  {
   continue;
  }

  /*!< 去掉文件(夹)只读等属性 */
  if(finder.IsReadOnly())
  {
   SetFileAttributes(finder.GetFilePath(), FILE_ATTRIBUTE_NORMAL);
  }

  if(finder.IsDirectory())
  {
   delDirectory(finder.GetFilePath());
   RemoveDirectory(finder.GetFilePath());
  }
  else
  {
   DeleteFile(finder.GetFilePath());
  }
 }
 finder.Close();
 RemoveDirectory(strDir);
}


/*!< 递归创建多级目录 */
#define  DIR_NAME_LENGTH 256

void CLjlFile::CreateMyFolder ( CString strFolderPath_t )
{
 wchar_t* strFolderPath;
 strFolderPath = strFolderPath_t.GetBuffer(0);
 TCHAR szDirName[DIR_NAME_LENGTH] = { 0 };
 TCHAR* pData = strFolderPath ;
 TCHAR* pszTemp = szDirName;
 CString str;
 str.Find(L"\\");
 
 while( *pData ) /*!< 递归创建多级目录 */
 {
  if ( ( '\\' == *pData ) || ( '/' == *pData ) )
  {
   if ( ':' != *( pData - 1 ) )
   {
    CreateDirectory( szDirName, NULL );// 依次创建一级目录
   }
  }            

  *pszTemp++ = *pData++;
  *pszTemp = '\0';
 }            

 CreateDirectory( szDirName, NULL );
}

/*!< 复制source中的内容到target中 */
void CLjlFile::myCopyDirectoryFiles(CString source, CString target) 
{ 
 CreateDirectory(target, NULL); /*!< 创建目标文件夹 */
 CFileFind finder; 
 CString path; 

 path.Format(L"%s/*.*", source); 
 BOOL bWorking = (BOOL)finder.FindFile(path);

 while(bWorking)
 { 
  bWorking = finder.FindNextFile();

  if(finder.IsDirectory() && !finder.IsDots())  //是文件夹 而且 名称不含 . 或 ..
  { 
   myCopyDirectoryFiles(finder.GetFilePath(), target + L"/" + finder.GetFileName()); //递归创建文件夹+"/"+finder.GetFileName() 
  } 
  else  //是文件，则直接复制
  {  
   CopyFile(finder.GetFilePath(), target + L"/" + finder.GetFileName(), FALSE); 
  }
 } 
}

/*************************************************************************
                proe安装目录检查,若未安装到标准目录,提示用户及修改                            
*************************************************************************/
void CLjlFile::myCheckDirectoryFiles(CString CheckPath, CString& info)
{
 CFileFind finderfiles;
 CString finderpath;

 finderpath.Format(L"%s/*.*", CheckPath); 
 BOOL bWorking = (BOOL)finderfiles.FindFile(finderpath);
 
 if (bWorking)
 {
  info = L"正确";
 }
 else
 {
  info = L"未安装到标准目录";
 }
 return;
}

void CLjlFile::myCheckDirectoryFiles_Modify(CString CheckPath, CString CopyPath, CString info)
{
 if (info == L"正确")
 {
  return;
 }
 CreateMyFolder(CheckPath);
 myCopyDirectoryFiles(CopyPath, CheckPath);
}

/************************************************************************
                  比较两列内容  config.pro启动项检查                        
************************************************************************/
std::vector<CString> vacbegin1;   // 存储第一个文本的第一列
std::vector<CString> vacbegin2;   // 存储第一个文本的第二列
std::vector<CString> vacend1;     // 存储第二个文本的第一列
std::vector<CString> vacend2;     // 存储第二个文本的第二列
std::vector<CString> vactotal;    // 存储第一个文本的一二两列
std::vector<int> m_spacebeginarr; // 存储第一个文本每一行的末位空格数
std::vector<int> m_spaceendarr;   // 存储第二个文本每一行的末位空格数

void CLjlFile::ReadBeginTxt( CString Path)
{
 vacbegin1.clear();
 vacbegin2.clear();
 m_spacebeginarr.clear();
 int beginnum = 0;
 CString csLine, csLineEnd, textbegin, textend;
 try
 {
  CStdioFile file(Path, CFile::modeRead | CFile::typeText);
  setlocale(LC_CTYPE, "chs");

  int begintxtLine = 0;
  while(file.ReadString(csLine))
  {
   if (csLine =="")
   {
    vacbegin1.push_back(L"`");
    vacbegin2.push_back(L"`");
    m_spacebeginarr.push_back(beginnum);
   }
   else
   {
    CString m_spacebegin = csLine;
    int m_spacebegincount = 0;

    while (m_spacebegin.Right(1) == " ")
    {
     m_spacebegincount++;
     m_spacebegin = m_spacebegin.Left(csLine.GetLength()-1);
     csLine = m_spacebegin;
    }

    if ((csLine.Find(L"!") != -1) || (csLine.Find(L"def_layer") != -1) || (csLine.Find(L"mapkey") != -1))
    {
     vacbegin1.push_back(L"`");
     vacbegin2.push_back(L"`");
     m_spacebeginarr.push_back(beginnum);
     continue;
    }

    int lineLenth = (int)wcslen(csLine);
    int nfrist = csLine.Find(L" "); 
    int i = 0;
    while(1)
    {
     if(nfrist != -1)
     {
      textbegin = csLine.Left(nfrist);

      if (i == 0 && !textbegin.IsEmpty())
      {
       vacbegin1.push_back(textbegin);
       i++;
      }

      textbegin = csLine.Right(lineLenth-nfrist-1); //减掉 1 为了去掉空格
      csLine = textbegin;
      if (csLine == "")
      {
       break;
      }
      nfrist = csLine.Find(L" ");
      lineLenth = csLine.GetLength();
     }
     else
     {
      vacbegin2.push_back(textbegin);
      break;
     }
    }

    //m_spacebeginarr[begintxtLine] = m_spacebegincount;
    m_spacebeginarr.push_back(m_spacebegincount);
    begintxtLine++;
   }
  }
  file.Close();
 }
 catch(...)
 {  
  AfxMessageBox(L"打开文件错");
 }
}

void CLjlFile::ReadEndTxt(CString Path)
{
 vacend1.clear();
 vacend2.clear();
 m_spaceendarr.clear();
 int endnum = 0;
 CString csLine, csLineEnd, textbegin, textend;
 try
 {
  CStdioFile file(Path, CFile::modeRead | CFile::typeText);
  setlocale(LC_CTYPE, "chs");

  int endtxtLine = 0;
  while(file.ReadString(csLine))
  {
   if (csLine == "")
   {
    continue;
   }
   CString m_spacebegin = csLine;
   int m_spaceendcount = 0;
   while (m_spacebegin.Right(1) == " ")
   {
    m_spaceendcount++;
    m_spacebegin = m_spacebegin.Left(csLine.GetLength()-1);
    csLine = m_spacebegin;
   }

   if ((csLine.Find(L"!") != -1) || (csLine.Find(L"def_layer") != -1) || (csLine.Find(L"mapkey") != -1))
   {
    continue;
   }

   int lineLenth = (int)wcslen(csLine);
   int nfrist = csLine.Find(L" "); 
   int i = 0;
   while(1)
   {
    if(nfrist != -1)
    {
     textbegin = csLine.Left(nfrist);


     if (i == 0 && !textbegin.IsEmpty())
     {
      vacend1.push_back(textbegin);
      i++;
     }

     textbegin = csLine.Right(lineLenth-nfrist-1); //减掉 1 为了去掉空格
     csLine = textbegin;
     if (csLine == "")
     {
      break;
     }
     nfrist = csLine.Find(L" ");
     lineLenth = csLine.GetLength();
    }
    else
    {
     vacend2.push_back(textbegin);
     break;
    }
   }
   //m_spaceendarr[endtxtLine] = m_spaceendcount;
   m_spaceendarr.push_back(m_spaceendcount);
   endtxtLine++;
  }
  file.Close();
 }
 catch(...)
 {  
  AfxMessageBox(L"打开文件错");
 }
}

void CLjlFile::ReadBeginTotalTxt(CString Path)
{
 vactotal.clear();
 CString csLine;
 try
 {
  CStdioFile file( Path, CFile::modeRead | CFile::typeText );
  setlocale(LC_CTYPE, "chs");

  while(file.ReadString(csLine))
  {
   vactotal.push_back(csLine);
  }
  file.Close();
 }
 catch(...)
 {  
  AfxMessageBox(L"打开文件错");
 }
}

void CLjlFile::ReadBeginEndTxtCompare()
{
 for (int k = 0; k < (int)vacend1.size(); k++)
 {
  for (int i = 0; i < (int)vactotal.size(); i++)
  {
   if (vactotal[i] == "")
   {
    continue;
   }

   if ((vactotal[i].Find(L"!") != -1) || (vactotal[i].Find(L"def_layer") != -1) || (vactotal[i].Find(L"mapkey") != -1))
   {
    continue;
   }
   if ( !wcscmp(vacbegin1[i], vacend1[k]))
   {
    if (!wcscmp(vacbegin2[i], vacend2[k]))
    {
     continue;
    }
    else
    {
     
     CString LeftString = vactotal[i].Left(vactotal[i].GetLength() - vacbegin2[i].GetLength() - m_spacebeginarr[i]);
     CString str;
     str.Format(L"%s%s", LeftString, vacend2[k]);
     while (m_spaceendarr[i])
     {
      str += L" ";
      m_spaceendarr[i]--;
     }
     vactotal[i].Replace(vactotal[i], str);
    }
   }
  }
 }
}

/*!< 写容器内容到文件中*/
void CLjlFile::WriteBeginTxtFinal( CString m_BeginPath )
{
 CString csLine;
 CStdioFile files(m_BeginPath, CFile::modeCreate | CFile::modeWrite | CFile::typeText);
 setlocale(LC_CTYPE, "chs");

 for (int j = 0; j < (int)vactotal.size(); j++)
 {
  if ( j < (int)vactotal.size() - 1 )
  {
   vactotal[j] += "\n";
  }
  files.Seek(0, CFile::end);
  files.WriteString(vactotal[j]); 
 }
 files.Flush();
 files.Close();
 //AfxMessageBox(L"更新完成！");
}

void CLjlFile::ReadBeginEndTxtCompare(CString& info)
{
 for (int k = 0; k < (int)vacend1.size(); k++)
 {
  for (int i = 0; i < (int)vactotal.size(); i++)
  {
   if (vactotal[i] == "")
   {
    continue;
   }

   if ((vactotal[i].Find(L"!") != -1) || (vactotal[i].Find(L"def_layer") != -1) || (vactotal[i].Find(L"mapkey") != -1))
   {
    continue;
   }
   if ( !wcscmp(vacbegin1[i], vacend1[k]))
   {
    if (!wcscmp(vacbegin2[i], vacend2[k]))
    {
     info = L"正确";
     continue;
    }
    else
    {
     info = L"与标准启动项不匹配";
     return;
    }
   }
  }
 }
}

void CLjlFile::WriteBeginTxtFinal_Modify(CString m_BeginPath, CString info)
{
 if (wcscmp(info, L"正确"))
 {
  ReadBeginEndTxtCompare();
  WriteBeginTxtFinal(m_BeginPath);
 }
}

/************************************************************************/
/*                            获取文件的信息                                   */
/************************************************************************/
void CLjlFile::myCheckedFileInformation( CString source, CString dest, CString FileName )
{
 CFileFind sourcefinder;
 CFileFind destfinder; 
 CString sourcepath, destpath, readpath, writepath;

 CString source_File_Time;
 ULONGLONG source_File_Size;
 CTime source_time_value;
 CString dest_File_Time;
 ULONGLONG dest_File_Size;
 CTime dest_time_value;
 int k = 0;


 sourcepath.Format(L"%s\\*.*", source);
 destpath.Format(L"%s\\*.*", dest);
 readpath.Format(L"%s\\%s", dest, FileName);
 writepath.Format(L"%s\\%s", source, FileName);

 ReadBeginTotalTxt(readpath);

 BOOL destWorking = (BOOL)destfinder.FindFile(destpath);
 while (destWorking)
 {
  destWorking = destfinder.FindNextFile();
  CString m_dest_FileName = destfinder.GetFileName();
  if (m_dest_FileName == FileName)
  {
   destfinder.GetLastWriteTime(dest_time_value);
   dest_File_Size = destfinder.GetLength();
   break;
  }
 }

 BOOL sourceWorking = (BOOL)sourcefinder.FindFile(sourcepath);
 while(sourceWorking)
 { 
  sourceWorking = sourcefinder.FindNextFile();
  CString m_FileName = sourcefinder.GetFileName();
  
  if (m_FileName != FileName)
  {
   continue;
  }

  sourcefinder.GetLastWriteTime(source_time_value);
  source_File_Size = sourcefinder.GetLength();

  if ((source_File_Size != dest_File_Size) || (source_time_value != dest_time_value))
  {
   k = AfxMessageBox(L"与标准文件不匹配,是否覆盖?", MB_OKCANCEL);
   switch(k)
   {
   case 1:
    WriteBeginTxtFinal(writepath);
    break;
   case 2:
    break;
   default:
    break;
   }
  }
  return ;
 }
 k = AfxMessageBox(L"没有所需要的文件,是否复制标准文件?", MB_OKCANCEL);
 switch(k)
 {
 case 2:
  break;
 case 1:
  //WriteBeginTxtFinal(writepath);
  CopyFile(readpath, writepath, FALSE);
  break;
 default:
  break;
 }
 return ;
}

void CLjlFile::myCheckedFileInformation( CString source, CString dest, CString FileName, CString& info )
{
 CFileFind sourcefinder;
 CFileFind destfinder; 
 CString sourcepath, readpath, writepath;

 CString source_File_Time;
 ULONGLONG source_File_Size;
 CTime source_time_value;
 CString dest_File_Time;
 ULONGLONG dest_File_Size;
 CTime dest_time_value;
 int k = 0;
 info = L"正确";


 sourcepath.Format(L"%s\\*.*", source);
 readpath.Format(L"%s\\%s", dest, FileName);
 writepath.Format(L"%s\\%s", source, FileName);

 BOOL destWorking = (BOOL)destfinder.FindFile(readpath);
 if (destWorking)
 {
  destfinder.GetLastWriteTime(dest_time_value);
  dest_File_Size = destfinder.GetLength();
 }

 BOOL sourceWorking = (BOOL)sourcefinder.FindFile(sourcepath);
 while(sourceWorking)
 { 
  sourceWorking = sourcefinder.FindNextFile();
  CString m_FileName = sourcefinder.GetFileName();

  if (m_FileName != FileName)
  {
   continue;
  }

  sourcefinder.GetLastWriteTime(source_time_value);
  source_File_Size = sourcefinder.GetLength();

  if ((source_File_Size != dest_File_Size) || (source_time_value != dest_time_value))
  {
   info = L"与标准文件不匹配";
   return;
  }
 }
 info = L"没有所需要的文件";
 return ;
}

void CLjlFile::myCheckedFileInformation_Modify( CString source, CString dest, CString FileName, CString info )
{
 CString readpath, writepath;
 readpath.Format(L"%s\\%s", dest, FileName);
 writepath.Format(L"%s\\%s", source, FileName);

 if (!wcscmp(info, L"正确"))
 {
  return;
 }
 else if (!wcscmp(info, L"与标准文件不匹配"))
 {
  ReadBeginTotalTxt(readpath);
  WriteBeginTxtFinal(writepath);
 }
 else if (!wcscmp(info, L"没有所需要的文件"))
 {
  CopyFile(readpath, writepath, FALSE);
 }
 return;
}

/*!< MDS文件目录检查 */
std::vector<CString> vaccheckpath; // 存储不标准文件路径
std::vector<CString> vacrightpath; // 存储标准文件路径
std::vector<CString> vacdifferentpath; // 存储与标准文件不同的文件路径

void CLjlFile::myCheckedSourceDirectoryFiles( CString source, CString m_source, CString& info)
{
 CFileFind finder; 
 CString path, strcatstring; 

 path.Format(L"%s/*.*", source); 
 BOOL bWorking = (BOOL)finder.FindFile(path);

 if (bWorking == 0)
 {
  info = L"路径不存在";
  return;
 }
 while(bWorking)
 { 
  bWorking = finder.FindNextFile();

  if (!finder.IsDots() && finder.IsDirectory())
  {
   myCheckedSourceDirectoryFiles(finder.GetFilePath(), m_source, info);
  }
  else
  {
   int m_len = m_source.GetLength();
   int len = source.GetLength();
   strcatstring = source.Right(len - m_len - 1);
   if (!wcscmp(source, m_source))
   {
    vaccheckpath.push_back(finder.GetFileName());
   }
   else
   {
    vaccheckpath.push_back(strcatstring + L"\\" + finder.GetFileName());
   }
  }
 }
}

void CLjlFile::myStatusTargetDirectoryFiles( CString target, CString m_target )
{
 CFileFind finder; 
 CString path, strcatstring; 

 path.Format(L"%s/*.*", target); 
 BOOL bWorking = (BOOL)finder.FindFile(path);

 while(bWorking)
 { 
  bWorking = finder.FindNextFile();

  if (!finder.IsDots() && finder.IsDirectory())
  {
   myStatusTargetDirectoryFiles(finder.GetFilePath(), m_target);
  }
  else
  {
   int m_len = m_target.GetLength();
   int len = target.GetLength();
   strcatstring = target.Right(len - m_len - 1);
   if (!wcscmp(target, m_target))
   {
    vacrightpath.push_back(finder.GetFileName());
   }
   else
   {
    vacrightpath.push_back(strcatstring + L"\\" + finder.GetFileName());
   }
  }
 }
}

void CLjlFile::myCopyFilesCompareToChecked( CString source, CString target )
{
 for (int i = 0; i < (int)vacdifferentpath.size(); i ++)
 {
  CString path, strcatstring; 

  path.Format(L"%s\\%s", source, vacdifferentpath[i]); 

  int npos = path.Find(L"\\");
  while (npos != -1)
  {
   strcatstring += path.Left(npos) + L"\\";
   path = path.Right(path.GetLength() - npos - 1);
   npos = path.Find(L"\\");
  }

  CreateMyFolder(strcatstring);
  CopyFile(target + L"\\" + vacdifferentpath[i], source + L"\\" + vacdifferentpath[i], FALSE);
 }
}

/*************************************************************
   MDS文件目录检查,是否缺少某些文件
*************************************************************/
void CLjlFile::myCheckedAndStatusDirectoryFilesCompare( CString source, CString m_source, CString target, CString m_target, CString& info )
{
 vaccheckpath.clear();
 vacrightpath.clear();

 myCheckedSourceDirectoryFiles(source, m_source, info);
 myStatusTargetDirectoryFiles(target, m_target);

 if (wcscmp(info, L"路径不存在"))
 {
  for (int status = 0; status < (int)vacrightpath.size(); status ++)
  {
   for (int checkcount = 0; checkcount < (int)vaccheckpath.size(); checkcount ++)
   {
    if (!wcscmp(vaccheckpath[checkcount], vacrightpath[status]))
    {
     break;
    }
    if ((wcscmp(vaccheckpath[checkcount], vacrightpath[status])) && (checkcount < (int)vaccheckpath.size() - 1))
    {
     continue;
    }
    if ((wcscmp(vaccheckpath[checkcount], vacrightpath[status])) && (checkcount = (int)vaccheckpath.size() - 1))
    {
     vacdifferentpath.push_back(vacrightpath[status]);
    }
   }
  }

  if ( vacdifferentpath.empty() )
  {
   info = L"正确";  
  }
  else
  {
   info = L"与标准路径不匹配";
  }
  return;
 }
}

void CLjlFile::myCheckedAndStatusDirectoryFilesCompare_Modify( CString source, CString target, CString info )
{
 if (!wcscmp(info, L"路径不存在"))
 {
  CreateMyFolder(source);
  myCopyDirectoryFiles(target, source);
  return;
 }
 if (!wcscmp(info, L"正确"))
 {
  return;
 }
 if (!wcscmp(info, L"与标准路径不匹配"))
 {
  myCopyFilesCompareToChecked(source, target);
 }
}

/***********************************************************
 检查MDA服务器名称 // hwnd 传参为 this->GetSafeHwnd()
***********************************************************/
void CLjlFile::myCheckMDAServersPath(CString& Path, HWND hwnd)
{
 TCHAR MyDir[MAX_PATH];

 SHGetSpecialFolderPath(hwnd, MyDir, CSIDL_APPDATA, 0);
 Path.Format(L"%s\\PTC\\ProENGINEER\\Wildfire\\.wf\\.Settings\\config.fld", MyDir);
}

void CLjlFile::myCheckMDAServersName( CString Path, CString& info )
{
 ReadBeginTotalTxt(Path); /*!< 将内容读到vactotal容器中*/

 for ( int i = 0; i < (int)vactotal.size(); i ++ )
 {
  CString str = L"label=";
  CString statusstr = L"\"mda\" ";
  int str_len = str.GetLength();
  if ( ( vactotal[i].Find(L"servers_nodes_info_ENTRY") != -1 ) && ( vactotal[i].Find(str) != -1 ) )
  {
   CString strcatstring, str_left, str_right;
   int npos = vactotal[i].Find( str );
   strcatstring = vactotal[i].Left( npos + str_len );
   str_right = vactotal[i].Right( vactotal[i].GetLength() - str_len - npos );
   npos = str_right.Find(L"online=");
   str_left = str_right.Left( npos );
   str_right = str_right.Right( str_right.GetLength() - npos );
   if ( str_left != statusstr )
   {
    info = L"MDA服务名器称不正确";
    vactotal[i] = strcatstring + statusstr + str_right ;
   }
   else
   {
    info = L"正确";
   }
  }
 }
}

void CLjlFile::myCheckMDAServersName_Modify( CString Path, CString info )
{
 if (!wcscmp(info, L"MDA服务名器称不正确"))
 {
  WriteBeginTxtFinal(Path);
 }
}

/*!<获取注册表中的安装信息，检查productview插件是否正确安装 */
#define MY_BUFSIZE 132
BOOL CLjlFile::ShowProductviewInformation(CString& info)
{
 HKEY hSubKey; 
 CString pathfull;
 long lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SoftWare\\PTC\\ProductView Express"), 0, KEY_READ, &hSubKey);

 if(ERROR_SUCCESS == lResult)
 {
  TCHAR s_Executable[256] = { 0 };
  TCHAR s_InstallationPath[256] = { 0 };

  DWORD typeSZ = REG_SZ;
  DWORD typeDWORD = REG_DWORD;
  DWORD dw_Executable = MY_BUFSIZE;
  DWORD dw_InstallationPath = MY_BUFSIZE;

  if ( (::RegQueryValueEx(hSubKey, _T("Executable"), 0, &typeSZ, (LPBYTE)s_Executable, &dw_Executable) == ERROR_SUCCESS) &&
   (::RegQueryValueEx(hSubKey, _T("InstallationPath"), 0, &typeSZ, (LPBYTE)s_InstallationPath, &dw_InstallationPath) == ERROR_SUCCESS) )
  { 
   pathfull.Format(L"%sbin\\pvexpress.exe", s_InstallationPath);

   CFileFind finder;
   BOOL bWorking = finder.FindFile(pathfull);
   if (bWorking)
   {
    info = L"正确";
   }
   else
   {
    info = L"插件未正确安装";
   }
  }
  else
  {
   info = L"插件未正确安装";
  }
  RegCloseKey(hSubKey);
  return TRUE;
 }
 info = L"插件未正确安装";
 RegCloseKey(hSubKey);
 return FALSE;
}

void CLjlFile::ShowProductviewInformation_Modify(HWND hWnd, CString Path, CString info)
{
 if (!wcscmp(info, L"插件未正确安装"))
 {
  ShellExecute(hWnd, L"open", Path, NULL, NULL, SW_SHOWNORMAL);
 }
}
//ShellExecute

 

Remington_
关注
西方艺术史-人文主义笔记
weixin_41049703的博客
06-01 4万+
人文主义 以人为本 和中世纪的精神差别 1、人的欲望 2、人的智慧 中世纪文学类型 1、宗教文学 2、英雄史诗 3、骑士文学 4、浪漫传奇 5、神曲 冰岛史诗：《埃达》，形式上有诗体和散文体，后者是对前者的解说。内容上分为创世史诗和英雄史诗两大类。 《萨迦（Saga）》是吟游诗人的作品，是一个新的文体。神话色彩少，是一部部家族史。神话色彩最浓的是《伏尔松萨迦》 saga在英语中几乎是史诗的代名词。 芬兰史诗：《卡莱瓦拉》 是一部推动芬兰独立的作品，20世纪才从口头流传到书面 德语史诗：《尼伯龙根之歌》 中
HCIA - 80期笔记 HCIA - 80期笔记
01-07
【HCIA - 80期笔记】主要涵盖了网络基础、数据封装、传输介质以及数据链路层的关键概念，这些知识对于理解计算机网络的工作原理至关重要。以下是详细的解释： 1. **网络的基本概念**： - 网络通信的起源：自1946年...
B站---【狂神说Java】JavaWeb入门到实战---笔记
热门推荐
bell_love的博客
04-23 18万+
JavaWebJava Web 1、基本概念web开发： ·web，网页的意思，www.baidu.com· 静态web 。html,sss 。提供给所有人看的数据始终不会发生变化！ 动态web 。淘宝，几乎是所有的网站； 。提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！ 。技术栈：Servlet/ISP，ASP，PHP ...
谷粒商城 - 个人笔记(基础篇一)
知行
09-26 5万+
电商后台管理系统+电商系统，掌握微服务的全套方案。该系统有商品服务、仓储服务、订单服务、购物车服务、检索服务、认证中心服务、网关服务、用户服务、秒杀服务、第三方服务。使用SpringBoot+SpringCloud并配套SpringCloud Alibaba系列，引入全套微服务治理方案：Nacos注册中心/配置中心、Feign远程调用、Gateway网关、Redisson缓存、基于ElasticSearch7全文检索、异步编排与线程池、RabbitMQ柔性事务方案、Redisson分布式锁、分布式信号量等。
uni-app 学习笔记 黑马优购商城
呆呆狗
07-05 8605
https://www.escook.cn/docs-uni-shop/ 1、uni-app 和项目搭建 1.1 项目介绍 1.2 文档介绍 项目接口文档 1.3 什么是 uni-app 就是基于 vue 的一个框架， 一套代码，可以打包成 多个端的方案 1.4 下载和安装 HB uni-app 官方 推荐使用 HB 开发 模板丰富 完善的智能提示 一键运行 安装步骤 访问官网 HB官网 点击首页的 DOWNLOAD 按钮 选择下载 正式版 => app开发板 1.5 安装 scss插
小迪安全2023期笔记汇总-持续更新
今天是几号的博客
03-03 1万+
基础入门-算法逆向&散列对称非对称&JS源码逆向&AES&DES&RSA&SHA。基础入门-HTTP数据包&Postman构造&请求方法&请求头修改&状态码判断。信息打点-Web应用&源码泄漏&开源闭源&指纹识别&GIT&SVN&DS&备份。基础入门-ChatGPT篇&注册体验&结合安全&融入技术&高效赋能&拓展需求。信息打点-Web应用&企业产权&指纹识别&域名资产&网络空间&威胁情报。
Java核心知识点整理大全21-笔记
私信up主，有惊喜
11-29 4823
不同的存储引擎提供不同的存储机制、索引技巧、锁定水平等功能，使用不同 的存储引擎，还可以 获得特定的功能。时间戳就是在数据库表中单独加一列时间戳，比如“TimeStamp”，每次读出来的时候，把该字 段也读出来，当写回去的时候，把该字段加1，提交之前 ，跟数据库的该字段比较一次，如果比数 据库的值大的话，就允许保存，否则不允许保存，这种处理方法虽然不使用数据库系统提供的锁 机制，但是这种方法可以大大提高数据库处理的并发量， 以上悲观锁所说的加“锁”，其实分为几种锁，分别是：排它锁（写锁）和共享锁（读锁）。
C语言-学习笔记完整版
Tosaybye的博客
08-27 4673
C语言基础知识
SAR学习笔记-代码部分
yjh_2019的博客
03-02 8810
目标检测、一维距离像、二维距离像以及SAR成像的RDA算法的代码实现
C#实现笔记本自带蓝牙与汇承HC-08(BLE)蓝牙模块通讯
Vishera的博客
05-12 5225
汇承HC-08蓝牙C#通讯 目录问题背景感谢BLE介绍参考代码参考业务逻辑参考库和例程难点介绍难点介绍新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 问题背景 因最近新项目需要与蓝牙仪器通讯，起初以为很简单，搜索一下C#蓝
群晖Synology DS918+使用笔记-基础篇
清风扬
10-16 3万+
DS918+搭载了英特尔最新一代赛扬J3455，基础频率1.5GHz，并且可以加速到2.3GHz，四核心，整合在CPU里的是最新一代的英特尔集显，支持两路视频实时转码。机器标配为4G的低电压DDR3内存。 DS918+属于Plus系列，定于与家庭高端型号，也适用于中小型企业，意味着上面有一些高级配置——比如多网口以及支持SSD缓存加速等。 外观 DS918+的外观沿袭了群晖系NAS...
完整第一期保荐代表人面授培训班讲解笔记-20120423.doc
09-11
完整第一期保荐代表人面授培训班讲解笔记-20120423.doc
2023-04-06-项目笔记 - 第六十六阶段 - 4.4.2.64全局变量的作用域-64 -2024.03.08
03-08
本篇笔记将重点讨论全局变量的作用域，并通过C语言的实例来加深理解。 #### 二、全局变量简介 全局变量是在所有函数之外声明的变量，可以在整个程序范围内被访问。与局部变量相比，全局变量在整个程序执行期间都...
2021一造案例土建-学霸笔记.pdf
10-07
【一级造价师考试知识点详解】 在一级造价师的考试中，建设项目的投资估算与财务评价是重要的考察内容。以下是对这一主题的详细解读： 1. **总投资构成**：建设项目总投资由固定资产投资（即工程造价）和流动资产...
基于SpringBoot仿天猫购物系统.zip(毕设&课设&实训&大作业&竞赛&项目)
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
Python网络爬虫与推荐算法新闻推荐平台(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-20
Python网络爬虫与推荐算法新闻推荐平台：网络爬虫：通过Python实现新浪新闻的爬取，可爬取新闻页面上的标题、文本、图片、视频链接（保留排版） 推荐算法：权重衰减+标签推荐+区域推荐+热点推荐.zip项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
THUCNews数据集
09-20
THUCNews数据集
Q音：Vue3+Pinia+Vue Router4+Vant4的移动端仿抖音短视频项目.zip(毕设&课设&实训&大作业&竞赛&
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
HCIA-80期笔记：网络基础与TCP/IP模型解析
总结来说，HCIA - 80期笔记是一个全面介绍网络基础和华为认证相关知识的培训课程，内容涵盖网络模型、数据传输原理、协议详解以及学习支持机制，旨在帮助学员深入理解和掌握网络技术的基础知识。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值