OTS/OTS_GB/OTSInterface/CFunExportForCSharp.h

#pragma once
#pragma managed
//支持C++.net的混合类型


//#include<iostream>
//#include<string>

using namespace System;      //for  String^
using namespace System::Runtime::InteropServices;    // for Marshal 使用


// 注意： 修改  配置属性->常规->公共语言运行时支持 修改为： 使用公共语言扩展 /clr

#include "CLogFile.h"
#include "COTSUtilityDllFunExport-old.h"

namespace NSFunExport
{
	namespace MethodFunction
	{
		class MFunction
		{
		public:
			MFunction() {}
			~MFunction() {}
			//将托管字符串转换成非托管的ANSI字符串 
		public:
			wchar_t* ManagedString2UnmanagedStringA(String^ strIn)
			{
				IntPtr ip = Marshal::StringToHGlobalAnsi(strIn);
				const wchar_t* pTemp = static_cast<const wchar_t*>(ip.ToPointer());
				wchar_t *pOut = new wchar_t[wcslen(pTemp) + 1];
				wcscpy_s(pOut, pTemp);
				Marshal::FreeHGlobal(ip);
				return pOut;
			}

			//将托管字符串转换成非托管的ANSI字符串 
			char* ManagedString2UnmanagedAcllStringA(String^ strIn)
			{
				IntPtr ip = Marshal::StringToHGlobalAnsi(strIn);
				const char* pTemp = static_cast<const char*>(ip.ToPointer());
				char *pOut = new char[strlen(pTemp) + 1];
				strcpy_s(pOut, pTemp);
				Marshal::FreeHGlobal(ip);
				return pOut;
			}

			//将非托管的ANSI字符串转换成托管字符串 
			String^ UnmanagedStringA2ManagedString(wchar_t *pIn)
			{
				String^ strOut = Marshal::PtrToStringAnsi(static_cast<IntPtr>(pIn));
				return strOut;
			}
		};
	}

}


namespace NSFunExport
{
	using namespace NSFunExport::MethodFunction;
	public ref class CFunExportClass
	{
		
	public:

		CFunExportClass()
		{
			m_LpFunMethod = new MFunction();
	//		m_LpUTools = new CUtilityTools();
		}

		~CFunExportClass()
		{
		/*	if (NULL != m_LpFunMethod)
			{
				delete m_LpFunMethod;
				m_LpFunMethod = NULL;
			}  */

// 			if (NULL != m_LpUTools)
// 			{
// 				delete m_LpUTools;
// 				m_LpUTools = NULL;
// 			}
		}

		void InitLog(String^ LogName)
		{
	/*		if (NULL != m_LpLogFile)
			{
				delete m_LpLogFile;
				m_LpLogFile = NULL;
			}

			char * lpStr = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(LogName);
			m_LpLogFile = new CCLogFile(lpStr);   */

			char * lpStr = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(LogName);

			InitLogFile_U(lpStr);
			if (NULL != lpStr)
			{
				delete[] lpStr; 
				lpStr = NULL;
			}

		}

		void EndCSharpLogFile()
		{			

			if (NULL != m_LpFunMethod)
			{
				delete m_LpFunMethod;
				m_LpFunMethod = NULL;
			}

			EndLogFile_U();



		/*	if (NULL != m_LpUTools)
			{
				delete m_LpUTools;
				m_LpUTools = NULL;
			}  */
		}

		// 打印Log信息
		BOOL TraceLog(String^ TraceData)
		{
		/*	if (NULL == m_LpLogFile)
			{
				return FALSE;
			}

			char * lpTraceData = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(TraceData);
			m_LpLogFile->TraceProgress(__FILE__, __LINE__, lpTraceData);  */

			char * lpTraceData = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(TraceData);
			LogTrace_U(__FILE__, __LINE__, lpTraceData);
			if (NULL != lpTraceData)
			{
				delete[] lpTraceData;
				lpTraceData = NULL;
			}
			return TRUE;
		}

		// 打印LogError信息
		BOOL TraceErrorLog(String^ TraceData)
		{
		/*	if (NULL == m_LpLogFile)
			{
				return FALSE;
			}

			char * lpTraceData = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(TraceData);
			m_LpLogFile->TraceError(__FILE__, __LINE__, lpTraceData);  */

			char * lpTraceData = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(TraceData);
			LogErrorTrace_U(__FILE__, __LINE__, lpTraceData);

			if (NULL != lpTraceData)
			{
				delete[] lpTraceData;
				lpTraceData = NULL;
			}
			return TRUE;
		}

/*
		// 打印Log异常信息
		BOOL TraceExceptionLog(String^ TraceData)
		{
			if (NULL == m_LpLogFile)
			{
				return FALSE;
			}

			char * lpTraceData = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(TraceData);
			m_LpLogFile->TraceException(__FILE__, __LINE__, lpTraceData);  

			return TRUE;
		}

		// 打印LogMessage信息
		BOOL TraceMessageLog(String^ TraceData)
		{
			if (NULL == m_LpLogFile)
			{
				return FALSE;
			}

			char * lpTraceData = m_LpFunMethod->ManagedString2UnmanagedAcllStringA(TraceData);
			m_LpLogFile->TraceMessage(__FILE__, __LINE__, lpTraceData);

			return TRUE;
		}

		*/
		// 打印Log二进制信息信息
		BOOL LogBinaryDataLog(array<System::Byte>^  byteArray)
		{
	/*		if (NULL == m_LpLogFile)
			{
				return FALSE;
			}

			pin_ptr<System::Byte> LpData = &byteArray[0];
			int ilen = byteArray->Length;
			m_LpLogFile->LogBinaryData("Binarry", LpData, ilen);   */

			pin_ptr<System::Byte> LpData = &byteArray[0];
			int ilen = byteArray->Length;
			LogBinaryTrace_U("Binarry", LpData, ilen);

			return TRUE;
		}


		//延迟时间
		BOOL Waiting(int iMilliseconds)
		{
		/*	if (NULL == m_LpUTools)
			{
				return FALSE;
			}

			m_LpUTools->WaitingWithEventLoop(iMilliseconds);  */

			WaitingTime_U(iMilliseconds);
			return TRUE;
		}




	/*	int GetAdd(int x, int y)
		{
			return x + y;
		}

		void LogString(String^ GetStr)
		{
			CString str = GetStr;
			AfxMessageBox(__T("C# 调用C++(clr)打印Log 成功"));
		}  */

	private:
		//	CCTest* m_Impl;

		//CCLogFile* m_LpLogFile;
		//CUtilityTools* m_LpUTools;
		//String^ csRev;
	//	BYTE* lpBData;
		

		//LPCWSTR lpLog;

		MFunction* m_LpFunMethod;

	};

}