기본 콘텐츠로 건너뛰기

www.pudn.com > ADO_S.rar > common.h

■ jwFreeNote_05
www.pudn.com > ADO_S.rar > common.h

/* 
 ******************************************************************************* 
 * 
 *               긢??긹?긚떎믅긏깋긚 
 * 
 *               긘긚긡?뼹     갌  떎믅긖깛긵깑 
 *               긐깑?긵뼹     갌  뻢떈굁괿굆굓 
 * 
 *               ??           갌  됪뽋룉뿚 (굑괷??붎) 
 *               룉뿚둜뾴       갌  긢??긹?긚먝뫏떎믅룉뿚 
 * 
 *               긫?긙깈깛     갌  1.00 
 *               띿맟볷         갌  2004/12/19 
 *               띿맟롌         갌   
 * 
 ******************************************************************************* 
*/ 
#if !defined(AFX_ADO2_H_INCLUDED_) 
#define AFX_ADO2_H_INCLUDED_ 
 
#if _MSC_VER >= 1000 
#pragma once 
#endif // _MSC_VER >= 1000 
#include  
#include  
#include  
//#include "C:\Program Files\Microsoft Analysis Services\Samples\Include\msmd.h" 
 
#pragma warning (disable: 4146) 
// CG : In order to use this code against a different version of ADO, the appropriate 
// ADO library needs to be used in the #import statement 
#import "C:\Program Files\Common Files\System\ADO\msado15.dll" rename("EOF", "EndOfFile") 
#import "C:\Program Files\Common Files\System\ado\MSJRO.DLL" no_namespace 
 
using namespace ADODB; 
 
 
#pragma warning (default: 4146) 
 
#include "icrsint.h" 
 
class CADOCommand; 
 
struct CADOFieldInfo 
{ 
 char m_strName[30];  
 short m_nType; 
 long m_lSize;  
 long m_lDefinedSize; 
 long m_lAttributes; 
 short m_nOrdinalPosition; 
 BOOL m_bRequired;    
 BOOL m_bAllowZeroLength;  
 long m_lCollatingOrder;   
}; 
 
CString IntToStr(int nVal); 
 
CString LongToStr(long lVal); 
 
CString ULongToStr(unsigned long ulVal); 
 
CString DblToStr(double dblVal, int ndigits = 20); 
 
CString DblToStr(float fltVal); 
 
class CADODatabase 
{ 
public: 
 enum cadoConnectModeEnum 
    {  
  connectModeUnknown = adModeUnknown, 
  connectModeRead = adModeRead, 
  connectModeWrite = adModeWrite, 
  connectModeReadWrite = adModeReadWrite, 
  connectModeShareDenyRead = adModeShareDenyRead, 
  connectModeShareDenyWrite = adModeShareDenyWrite, 
  connectModeShareExclusive = adModeShareExclusive, 
  connectModeShareDenyNone = adModeShareDenyNone 
    }; 
 
 CADODatabase() 
 { 
  ::CoInitialize(NULL); 
    
  m_pConnection = NULL; 
  m_strConnection = _T(""); 
  m_strLastError = _T(""); 
  m_dwLastError = 0; 
  m_pConnection.CreateInstance(__uuidof(Connection)); 
  m_nRecordsAffected = 0; 
  m_nConnectionTimeout = 0; 
 } 
  
 virtual ~CADODatabase() 
 { 
  Close(); 
  m_pConnection.Release(); 
  m_pConnection = NULL; 
  m_strConnection = _T(""); 
  m_strLastError = _T(""); 
  m_dwLastError = 0; 
  ::CoUninitialize(); 
 } 
  
 BOOL Open(LPCTSTR lpstrConnection = _T(""), LPCTSTR lpstrUserID = _T(""), LPCTSTR lpstrPassword = _T("")); 
 _ConnectionPtr GetActiveConnection()  
  {return m_pConnection;}; 
 BOOL Execute(LPCTSTR lpstrExec); 
 int GetRecordsAffected() 
  {return m_nRecordsAffected;}; 
 DWORD GetRecordCount(_RecordsetPtr m_pRs); 
 long BeginTransaction()  
  {return m_pConnection->BeginTrans();}; 
 long CommitTransaction()  
  {return m_pConnection->CommitTrans();}; 
 long RollbackTransaction()  
  {return m_pConnection->RollbackTrans();}; 
 BOOL IsOpen(); 
 void Close(); 
 void SetConnectionMode(cadoConnectModeEnum nMode) 
  {m_pConnection->PutMode((enum ConnectModeEnum)nMode);}; 
 void SetConnectionString(LPCTSTR lpstrConnection) 
  {m_strConnection = lpstrConnection;}; 
 CString GetConnectionString() 
  {return m_strConnection;}; 
 CString GetLastErrorString()  
  {return m_strLastError;}; 
 DWORD GetLastError() 
  {return m_dwLastError;}; 
 CString GetErrorDescription()  
  {return m_strErrorDescription;}; 
 void SetConnectionTimeout(long nConnectionTimeout = 30) 
  {m_nConnectionTimeout = nConnectionTimeout;}; 
 
protected: 
 void dump_com_error(_com_error &e); 
 
public: 
 _ConnectionPtr m_pConnection; 
 
protected: 
 CString m_strConnection; 
 CString m_strLastError; 
 CString m_strErrorDescription; 
 DWORD m_dwLastError; 
 int m_nRecordsAffected; 
 long m_nConnectionTimeout; 
}; 
 
class CADORecordset 
{ 
public: 
 BOOL Clone(CADORecordset& pRs); 
  
 enum cadoOpenEnum 
 { 
  openUnknown = 0, 
  openQuery = 1, 
  openTable = 2, 
  openStoredProc = 3 
 }; 
 
 enum cadoEditEnum 
 { 
  dbEditNone = 0, 
  dbEditNew = 1, 
  dbEdit = 2 
 }; 
  
 enum cadoPositionEnum 
 { 
  
  positionUnknown = -1, 
  positionBOF = -2, 
  positionEOF = -3 
 }; 
  
 enum cadoSearchEnum 
 {  
  searchForward = 1, 
  searchBackward = -1 
 }; 
 
 enum cadoDataType 
 { 
  typeEmpty = ADODB::adEmpty, 
  typeTinyInt = ADODB::adTinyInt, 
  typeSmallInt = ADODB::adSmallInt, 
  typeInteger = ADODB::adInteger, 
  typeBigInt = ADODB::adBigInt, 
  typeUnsignedTinyInt = ADODB::adUnsignedTinyInt, 
  typeUnsignedSmallInt = ADODB::adUnsignedSmallInt, 
  typeUnsignedInt = ADODB::adUnsignedInt, 
  typeUnsignedBigInt = ADODB::adUnsignedBigInt, 
  typeSingle = ADODB::adSingle, 
  typeDouble = ADODB::adDouble, 
  typeCurrency = ADODB::adCurrency, 
  typeDecimal = ADODB::adDecimal, 
  typeNumeric = ADODB::adNumeric, 
  typeBoolean = ADODB::adBoolean, 
  typeError = ADODB::adError, 
  typeUserDefined = ADODB::adUserDefined, 
  typeVariant = ADODB::adVariant, 
  typeIDispatch = ADODB::adIDispatch, 
  typeIUnknown = ADODB::adIUnknown, 
  typeGUID = ADODB::adGUID, 
  typeDate = ADODB::adDate, 
  typeDBDate = ADODB::adDBDate, 
  typeDBTime = ADODB::adDBTime, 
  typeDBTimeStamp = ADODB::adDBTimeStamp, 
  typeBSTR = ADODB::adBSTR, 
  typeChar = ADODB::adChar, 
  typeVarChar = ADODB::adVarChar, 
  typeLongVarChar = ADODB::adLongVarChar, 
  typeWChar = ADODB::adWChar, 
  typeVarWChar = ADODB::adVarWChar, 
  typeLongVarWChar = ADODB::adLongVarWChar, 
  typeBinary = ADODB::adBinary, 
  typeVarBinary = ADODB::adVarBinary, 
  typeLongVarBinary = ADODB::adLongVarBinary, 
  typeChapter = ADODB::adChapter, 
  typeFileTime = ADODB::adFileTime, 
  typePropVariant = ADODB::adPropVariant, 
  typeVarNumeric = ADODB::adVarNumeric, 
  typeArray = ADODB::adVariant 
 }; 
  
 enum cadoSchemaType  
 { 
  schemaSpecific = adSchemaProviderSpecific,  
  schemaAsserts = adSchemaAsserts, 
  schemaCatalog = adSchemaCatalogs, 
  schemaCharacterSet = adSchemaCharacterSets, 
  schemaCollections = adSchemaCollations, 
  schemaColumns = adSchemaColumns, 
  schemaConstraints = adSchemaCheckConstraints, 
  schemaConstraintColumnUsage = adSchemaConstraintColumnUsage, 
  schemaConstraintTableUsage  = adSchemaConstraintTableUsage, 
  shemaKeyColumnUsage = adSchemaKeyColumnUsage, 
  schemaTableConstraints = adSchemaTableConstraints, 
  schemaColumnsDomainUsage = adSchemaColumnsDomainUsage, 
  schemaIndexes = adSchemaIndexes, 
  schemaColumnPrivileges = adSchemaColumnPrivileges, 
  schemaTablePrivileges = adSchemaTablePrivileges, 
  schemaUsagePrivileges = adSchemaUsagePrivileges, 
  schemaProcedures = adSchemaProcedures, 
  schemaTables =adSchemaTables, 
  schemaProviderTypes = adSchemaProviderTypes, 
  schemaViews = adSchemaViews, 
  schemaProcedureParameters = adSchemaProcedureParameters, 
  schemaForeignKeys = adSchemaForeignKeys, 
  schemaPrimaryKeys = adSchemaPrimaryKeys, 
  schemaProcedureColumns = adSchemaProcedureColumns, 
  schemaDBInfoKeywords = adSchemaDBInfoKeywords, 
  schemaDBInfoLiterals = adSchemaDBInfoLiterals, 
  schemaCubes = adSchemaCubes, 
  schemaDimensions = adSchemaDimensions, 
  schemaHierarchies  = adSchemaHierarchies,  
  schemaLevels = adSchemaLevels, 
  schemaMeasures = adSchemaMeasures, 
  schemaProperties = adSchemaProperties, 
  schemaMembers = adSchemaMembers, 
 };  
 
 
 BOOL SetFieldValue(int nIndex, int nValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, int nValue); 
 BOOL SetFieldValue(int nIndex, long lValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, long lValue); 
 BOOL SetFieldValue(int nIndex, unsigned long lValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, unsigned long lValue); 
 BOOL SetFieldValue(int nIndex, double dblValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, double dblValue); 
 BOOL SetFieldValue(int nIndex, CString strValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, CString strValue); 
 BOOL SetFieldValue(int nIndex, COleDateTime time); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, COleDateTime time); 
 BOOL SetFieldValue(int nIndex, bool bValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, bool bValue); 
 BOOL SetFieldValue(int nIndex, COleCurrency cyValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, COleCurrency cyValue); 
 BOOL SetFieldValue(int nIndex, _variant_t vtValue); 
 BOOL SetFieldValue(LPCTSTR lpFieldName, _variant_t vtValue); 
 
 BOOL SetFieldEmpty(int nIndex); 
 BOOL SetFieldEmpty(LPCTSTR lpFieldName); 
 
 void CancelUpdate(); 
 BOOL Update(); 
 void Edit(); 
 BOOL AddNew(); 
 BOOL AddNew(CADORecordBinding &pAdoRecordBinding); 
 
 BOOL Find(LPCTSTR lpFind, int nSearchDirection = CADORecordset::searchForward); 
 BOOL FindFirst(LPCTSTR lpFind); 
 BOOL FindNext(); 
 
 CADORecordset(); 
 
 CADORecordset(CADODatabase* pAdoDatabase); 
 
 virtual ~CADORecordset() 
 { 
  Close(); 
  if(m_pRecordset) 
   m_pRecordset.Release(); 
  if(m_pCmd) 
   m_pCmd.Release(); 
  m_pRecordset = NULL; 
  m_pCmd = NULL; 
  m_pRecBinding = NULL; 
  m_strQuery = _T(""); 
  m_strLastError = _T(""); 
  m_dwLastError = 0; 
  m_nEditStatus = dbEditNone; 
 } 
 
 CString GetQuery()  
  {return m_strQuery;}; 
 void SetQuery(LPCSTR strQuery)  
  {m_strQuery = strQuery;}; 
 BOOL RecordBinding(CADORecordBinding &pAdoRecordBinding); 
 DWORD GetRecordCount(); 
 BOOL IsOpen(); 
 void Close(); 
 BOOL Open(_ConnectionPtr mpdb, LPCTSTR lpstrExec = _T(""), int nOption = CADORecordset::openUnknown); 
 BOOL Open(LPCTSTR lpstrExec = _T(""), int nOption = CADORecordset::openUnknown); 
 BOOL OpenSchema(int nSchema, LPCTSTR SchemaID = _T("")); 
 long GetFieldCount() 
  {return m_pRecordset->Fields->GetCount();}; 
 BOOL GetFieldValue(LPCTSTR lpFieldName, int& nValue); 
 BOOL GetFieldValue(int nIndex, int& nValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, long& lValue); 
 BOOL GetFieldValue(int nIndex, long& lValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, unsigned long& ulValue); 
 BOOL GetFieldValue(int nIndex, unsigned long& ulValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, double& dbValue); 
 BOOL GetFieldValue(int nIndex, double& dbValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, CString& strValue, CString strDateFormat = _T("")); 
 BOOL GetFieldValue(int nIndex, CString& strValue, CString strDateFormat = _T("")); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, COleDateTime& time); 
 BOOL GetFieldValue(int nIndex, COleDateTime& time); 
 BOOL GetFieldValue(int nIndex, bool& bValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, bool& bValue); 
 BOOL GetFieldValue(int nIndex, COleCurrency& cyValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, COleCurrency& cyValue); 
 BOOL GetFieldValue(int nIndex, _variant_t& vtValue); 
 BOOL GetFieldValue(LPCTSTR lpFieldName, _variant_t& vtValue); 
  
 BOOL IsFieldNull(LPCTSTR lpFieldName); 
 BOOL IsFieldNull(int nIndex); 
 BOOL IsFieldEmpty(LPCTSTR lpFieldName); 
 BOOL IsFieldEmpty(int nIndex);  
 BOOL IsEof() 
  {return m_pRecordset->EndOfFile == VARIANT_TRUE;}; 
 BOOL IsEOF() 
  {return m_pRecordset->EndOfFile == VARIANT_TRUE;}; 
 BOOL IsBof() 
  {return m_pRecordset->BOF == VARIANT_TRUE;}; 
 BOOL IsBOF() 
  {return m_pRecordset->BOF == VARIANT_TRUE;}; 
 void MoveFirst()  
  {m_pRecordset->MoveFirst();}; 
 void MoveNext()  
  {m_pRecordset->MoveNext();}; 
 void MovePrevious()  
  {m_pRecordset->MovePrevious();}; 
 void MoveLast()  
  {m_pRecordset->MoveLast();}; 
 long GetAbsolutePage() 
  {return m_pRecordset->GetAbsolutePage();}; 
 void SetAbsolutePage(int nPage) 
  {m_pRecordset->PutAbsolutePage((enum PositionEnum)nPage);}; 
 long GetPageCount() 
  {return m_pRecordset->GetPageCount();}; 
 long GetPageSize() 
  {return m_pRecordset->GetPageSize();}; 
 void SetPageSize(int nSize) 
  {m_pRecordset->PutPageSize(nSize);}; 
 long GetAbsolutePosition() 
  {return m_pRecordset->GetAbsolutePosition();}; 
 void SetAbsolutePosition(int nPosition) 
  {m_pRecordset->PutAbsolutePosition((enum PositionEnum)nPosition);}; 
 BOOL GetFieldInfo(LPCTSTR lpFieldName, CADOFieldInfo* fldInfo); 
 BOOL GetFieldInfo(int nIndex, CADOFieldInfo* fldInfo); 
 BOOL AppendChunk(LPCTSTR lpFieldName, LPVOID lpData, UINT nBytes); 
 BOOL AppendChunk(int nIndex, LPVOID lpData, UINT nBytes); 
 
 BOOL GetChunk(LPCTSTR lpFieldName, CString& strValue); 
 BOOL GetChunk(int nIndex, CString& strValue); 
  
 BOOL GetChunk(LPCTSTR lpFieldName, LPVOID pData); 
 BOOL GetChunk(int nIndex, LPVOID pData); 
 
 CString GetString(LPCTSTR lpCols, LPCTSTR lpRows, LPCTSTR lpNull, long numRows = 0); 
 CString GetLastErrorString()  
  {return m_strLastError;}; 
 DWORD GetLastError() 
  {return m_dwLastError;}; 
 void GetBookmark() 
  {m_varBookmark = m_pRecordset->Bookmark;}; 
 BOOL SetBookmark(); 
 BOOL Delete(); 
 BOOL IsConnectionOpen() 
  {return m_pConnection != NULL && m_pConnection->GetState() != adStateClosed;}; 
 _RecordsetPtr GetRecordset() 
  {return m_pRecordset;}; 
 _ConnectionPtr GetActiveConnection()  
  {return m_pConnection;}; 
 
 BOOL SetFilter(LPCTSTR strFilter); 
 BOOL SetSort(LPCTSTR lpstrCriteria); 
 BOOL SaveAsXML(LPCTSTR lpstrXMLFile); 
 BOOL OpenXML(LPCTSTR lpstrXMLFile); 
 BOOL Execute(CADOCommand* pCommand); 
 BOOL Requery(); 
 
public: 
 void SetDatabase(CADODatabase * pDB); 
 _RecordsetPtr m_pRecordset; 
 _CommandPtr m_pCmd; 
  
protected: 
 _ConnectionPtr m_pConnection; 
 int m_nSearchDirection; 
 CString m_strFind; 
 _variant_t m_varBookFind; 
 _variant_t m_varBookmark; 
 int m_nEditStatus; 
 CString m_strLastError; 
 DWORD m_dwLastError; 
 void dump_com_error(_com_error &e); 
 IADORecordBinding *m_pRecBinding; 
 CString m_strQuery; 
 
protected: 
 BOOL PutFieldValue(LPCTSTR lpFieldName, _variant_t vtFld); 
 BOOL PutFieldValue(_variant_t vtIndex, _variant_t vtFld); 
 BOOL GetFieldInfo(FieldPtr pField, CADOFieldInfo* fldInfo); 
 BOOL GetChunk(FieldPtr pField, CString& strValue); 
 BOOL GetChunk(FieldPtr pField, LPVOID lpData); 
 BOOL AppendChunk(FieldPtr pField, LPVOID lpData, UINT nBytes); 
   
}; 
 
class CADOParameter 
{ 
public: 
 
 enum cadoParameterDirection 
 { 
  paramUnknown = adParamUnknown, 
  paramInput = adParamInput, 
  paramOutput = adParamOutput, 
  paramInputOutput = adParamInputOutput, 
  paramReturnValue = adParamReturnValue  
 }; 
 
 CADOParameter(int nType, long lSize = 0, int nDirection = paramInput, CString strName = _T("")); 
  
 virtual ~CADOParameter() 
 { 
  m_pParameter.Release(); 
  m_pParameter = NULL; 
  m_strName = _T(""); 
 } 
 
 BOOL SetValue(int nValue); 
 BOOL SetValue(long lValue); 
 BOOL SetValue(double dbValue); 
 BOOL SetValue(CString strValue); 
 BOOL SetValue(COleDateTime time); 
 BOOL SetValue(_variant_t vtValue); 
 BOOL GetValue(int& nValue); 
 BOOL GetValue(long& lValue); 
 BOOL GetValue(double& dbValue); 
 BOOL GetValue(CString& strValue, CString strDateFormat = _T("")); 
 BOOL GetValue(COleDateTime& time); 
 BOOL GetValue(_variant_t& vtValue); 
 void SetPrecision(int nPrecision) 
  {m_pParameter->PutPrecision(nPrecision);}; 
 void SetScale(int nScale) 
  {m_pParameter->PutNumericScale(nScale);}; 
 
 void SetName(CString strName) 
  {m_strName = strName;}; 
 CString GetName() 
  {return m_strName;}; 
 int GetType() 
  {return m_nType;}; 
 _ParameterPtr GetParameter() 
  {return m_pParameter;}; 
 
protected: 
 void dump_com_error(_com_error &e); 
  
protected: 
 _ParameterPtr m_pParameter; 
 CString m_strName; 
 int m_nType; 
 CString m_strLastError; 
 DWORD m_dwLastError; 
}; 
 
class CADOCommand 
{ 
public: 
 enum cadoCommandType 
 { 
  typeCmdText = adCmdText, 
  typeCmdTable = adCmdTable, 
  typeCmdTableDirect = adCmdTableDirect, 
  typeCmdStoredProc = adCmdStoredProc, 
  typeCmdUnknown = adCmdUnknown, 
  typeCmdFile = adCmdFile 
 }; 
  
 CADOCommand(CADODatabase* pAdoDatabase, CString strCommandText = _T(""), int nCommandType = typeCmdStoredProc); 
   
 virtual ~CADOCommand() 
 { 
  m_pCommand.Release(); 
  m_pCommand = NULL; 
  m_strCommandText = _T(""); 
 } 
 
 void SetTimeout(long nTimeOut) 
  {m_pCommand->PutCommandTimeout(nTimeOut);}; 
 void SetText(CString strCommandText); 
 void SetType(int nCommandType); 
 int GetType() 
  {return m_nCommandType;}; 
 BOOL AddParameter(CADOParameter* pAdoParameter); 
 BOOL AddParameter(CString strName, int nType, int nDirection, long lSize, int nValue); 
 BOOL AddParameter(CString strName, int nType, int nDirection, long lSize, long lValue); 
 BOOL AddParameter(CString strName, int nType, int nDirection, long lSize, double dblValue, int nPrecision = 0, int nScale = 0); 
 BOOL AddParameter(CString strName, int nType, int nDirection, long lSize, CString strValue); 
 BOOL AddParameter(CString strName, int nType, int nDirection, long lSize, COleDateTime time); 
 BOOL AddParameter(CString strName, int nType, int nDirection, long lSize, _variant_t vtValue, int nPrecision = 0, int nScale = 0); 
 CString GetText() 
  {return m_strCommandText;}; 
 BOOL Execute(); 
 int GetRecordsAffected() 
  {return m_nRecordsAffected;}; 
 _CommandPtr GetCommand() 
  {return m_pCommand;}; 
 
protected: 
 void dump_com_error(_com_error &e); 
 
protected: 
 _CommandPtr m_pCommand; 
 int m_nCommandType; 
 int m_nRecordsAffected; 
 CString m_strCommandText; 
 CString m_strLastError; 
 DWORD m_dwLastError; 
}; 
 
class CADOException : public CException 
{ 
public: 
 
 enum 
 { 
  noError, // no error 
  Unknown, // unknown error 
 }; 
 
 DECLARE_DYNAMIC(CADOException); 
  
 CADOException(int nCause = 0, CString strErrorString = _T("")); 
 virtual ~CADOException(); 
 
 static int GetError(int nADOError); 
 
public: 
 int m_nCause; 
  CString m_strErrorString; 
  
protected: 
  
}; 
 
void AfxThrowADOException(int nADOError = 1000, CString strErrorString = _T("")); 
 
#endif //AFX_ADO2_H_INCLUDED_ 






window.google_render_ad(); 
 
 
 
 

댓글

이 블로그의 인기 게시물

80040154 오류로 인해 CLSID가 {xxxx-...}인 구성 요소의 COM 클래스 팩터리를 검색하지 못했습니다.

원문보기 .NET 으로 만든 응용프로그램에서 com 객체를 호출한 경우 Windows7 64bit 에서 제목과 같은 에러가 발생했다. Win32 COM 과 .NET 프로그램간의 호환성 때문에 생긴 문제였다. 원인은 .NET 실행시 JIT 컴파일러에 의해 최적화된 기계어로 변환되기 때문.. Win32 COM은 컴파일시.. Win32 COM에 맞춰 빌드 속성에서 하위버전으로 맞춰 컴파일을 다시하는 방법도 있지만 메인 프로젝트가 .NET이라면 참조되는 모든 프로젝트를 다 바꿔야할 노릇.. 또 다른 방법은 COM+를 이용하여 독립적으로 만드는 것이다. 분리시키는 방법은 아래 주소해서 확인할 수 있다. http://support.microsoft.com/kb/281335 나의 경우는 Win32 COM DLL을 64비트 .NET 프로그램에서 참조하니 COM 객체를 제대로 호출하지 못하였습니다. 그래서 .NET 프로그램의 Target Machine을 x86으로 설정하니 제대로 COM 객체를 호출하였습니다.

[Pyinstaller] 실행 파일 관리자 권한 획득하기

고객사에서 일부 사용자에게서 프로그램 오류가 발생한다며 아래와 같이 에러 캡처를 보내왔습니다. 프로그램에서 로그를 남기기 위해 로그 파일을 생성하는데 권한의 문제로 로그 파일을 생성하지 못해 프로그램 오류가 발생한 것 같습니다. 처음에는 Python 코드에서 관리자 권한을 요청하는 코드를 넣으려고 했는데, 실제로 Stackoverflow를 찾아보면 이런 내용이 나옵니다. 프로그램이 관리자 권한으로 실행되지 않았다면 관리자 권한으로 다시 프로그램을 실행시키는 코드입니다. import os import sys import win32com.shell.shell as shell ASADMIN = 'asadmin' if sys.argv[-1] != ASADMIN: script = os.path.abspath(sys.argv[0]) params = ' '.join([script] + sys.argv[1:] + [ASADMIN]) shell.ShellExecuteEx(lpVerb='runas', lpFile=sys.executable, lpParameters=params) sys.exit(0) 하지만 개인적으로 이런 방식은 마음에 들지 않았고 조금 더 찾아보니 Pyinstaller로 exe 파일을 만들 때 옵션을 설정하여 관리자 권한을 요청하도록 할 수 있다고 합니다. --uac-admin을 옵션에 추가하면 프로그램 실행 시 관리자 권한을 요청할 수 있습니다. pyinstaller.exe --uac-admin sample.py 하지만 안타깝게도 이 방식은 원하는 대로 동작하지 않았습니다. 마지막으로 manifest 파일을 이용하여 시도해보았습니다. spec 파일을 이용하여 pyinstaller로 빌드하면 <실행 파일 이름>.manifest 라는 파일이 생성됩니다. 파일에서 아랫부분을 찾아볼 수 있습니다. <security> <re

초간단 프로그램 락 걸기

프로그램에 락을 걸 일이 생겨났다. 하드웨어 락을 걸면 쉬울텐데 그 정도는 아니고 프로그램의 실행 날짜를 제한 해 달라고 한다. 그래서 파일(license.lic)을 가지고 락을 걸리고 결정을 했다. 요구 사항은 아래와 같다. 1. license.lic 파일이 없으면 프로그램을 실행 할수 없게 한다. 2. 지정한 날짜를 넘어서는 프로그램을 실행 할수 없게 한다. 3. 사용자가 시스템 날짜를 되돌렸을때 인식하여 프로그램을 실행 할수 없게 한다. 음.... 1.번 문제는 사용자가 프로그램을 실행하기 위해서 license.lic 파일을 받아야만 한다. license.lic 파일에는 최근 실행 날짜/종료날짜 이런식으로 적도록 한다.(물론 내용은 암호화 한다.) 최근 실행날짜는 프로그램이 실행때마다 업데이트 하도록 하고 시스템 날짜와 비교하여 시스템 날짜가 최근 실행 날짜보다 이전의 날짜면 시스템 날짜를 되돌렸다고 인식하도록 한다.(3.번 문제 해결) 시스템 날짜와 종료 날짜를 비교하여 시스템 날짜가 종료 날짜를 넘으면 프로그램을 실행 할수 없도록 한다.(2.번 문제 해결)