▄︻┳一

C#与Flash交互

58599886@qq.com(▄︻┳一) — Thu, 08 Oct 2009 06:43:58 GMT

C#与Flash交互
前段日子公司要求做一个C#与Flash交互的东西，用来C#与短信猫通讯将数据传到Flash上显示与操作的应用。

第一步C#添加组件
打开VS2005-工具-选择工具箱项-COM组件-选择Shockwave Flash Object-确定
添加好组件往场景上拖放，如果提示注册需求注册
c# 注册控件-在运行输入-回车（flash9f.ocx这个文件以系统中实际文件为准。）
regsvr32 c:\windows\system32\macromed\flash\flash9f.ocx
或者regsvr32 c:\windows\system32\macromed\flash\flash10a.ocx

第二步将Flash组件拖入场景
将Flash组件拖入场景，设置加载的swf路径。设置组件id。
组件的Movie属性：指定要播放的swf的路径，
如果swf在本地硬盘，则需要写成从盘符开始的绝对路径
如果swf在某网站上，则需要写成完全的url网址
更多该组件属性/方法

第三步AS代码片段
刚开始用FSCommand与网页VBSCRIPT做了一个通讯，以为这样就能与C#通讯了，结果错误了。
还得用ExternalInterface.addCallback，ExternalInterface.call的方法来与C#通讯。

程序代码
import flash.external.*;
//向C#发送数据
ExternalInterface.call ("test", "str", Math.random ());
//接受C#发来的数据
ExternalInterface.addCallback ("c2flash", null, c2flash);
function c2flash (s:String)
{
out_txt.text = s;
}

第四步C#代码片段
程序代码
private void Form1_Load(object sender, EventArgs e)
{
flash.Movie = "E:/c2flash.swf";
flash.FlashCall += new AxShockwaveFlashObjects._IShockwaveFlashEvents_FlashCallEventHandler(flash_FlashCall);
}

void flash_FlashCall(object sender, AxShockwaveFlashObjects._IShockwaveFlashEvents_FlashCallEvent e)
{
string s = nodeXml(e.request.ToString())[0].ChildNodes[0].InnerText.ToString();
//接受Flash传来的值
this.textBox1.Text = s;
throw new Exception("The method or operation is not implemented.");
}
private void button1_Click(object sender, EventArgs e)
{
//向Flash发送数据
callFunction("c2flash",this.textBox1.Text);
}
private void callFunction(string funName,string arg)
{
//C#传给Flash的值
flash.CallFunction(""+arg+"");
}
private XmlNodeList nodeXml(string s)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(s);
XmlNodeList list = doc.GetElementsByTagName("arguments");
return list;
}

.net中有关IE编程

58599886@qq.com(▄︻┳一) — Tue, 29 Sep 2009 10:16:12 GMT

webbrowers 控件
打开网页，
Object url="http:///index2.asp";
axWebBrowser1.Navigate2(ref url);
其中Navigate2方法比Navigate方法多了一些功能，比如打开文件夹（没试过）
NavigateComplete事件在DocumentComplete事件之前执行
已模似网页操作为例子
如果是做winform程序
比如你要进行打开网页，填写数据，点击提交等操作
下面代码
int cmdNum
private void button1_Click(object sender, System.EventArgs e)
{
　Object url="http:///index2.asp";
axWebBrowser1.Navigate2(ref url);
} private void Form1_Load(object sender, System.EventArgs e)
{
//命令集合
al=new ArrayList();
al.Add(new command(1,"staff_name_en","InputText","zuoqs"));
al.Add(new command(2,"password","InputText","js020508"));
al.Add(new command(3,"submit","submit","{enter}"));
}private void axWebBrowser1_DocumentComplete(object sender, AxSHDocVw.DWebBrowserEvents2_DocumentCompleteEvent e)
{
timer1.Enabled=false;//计时器暂停
axWebBrowser1.Focus();
mshtml.HTMLDocumentClass doc=(mshtml.HTMLDocumentClass)axWebBrowser1.Document;
if(doc.location.href.IndexOf("mis/index2.asp")>-1)
{
if(doc.body.innerText.IndexOf("你不是合法用户")>-1||doc.body.innerText.IndexOf("你的口令输入错误")>-1)
{
label1.Text="登陆失败";
timer1.Enabled=false;
return;
}
}

timer1.Enabled=true;//处理完逻辑后开启
} private void timer1_Tick(object sender, System.EventArgs e)
{
timer1.Enabled=false;//计时器暂停
axWebBrowser1.Focus();//控件焦点获取
if(cmdNum==al.Count)
{
timer1.Enabled=false;//如果命令执行完后计时器暂停
}
else
{
mshtml.HTMLDocumentClass doc=(mshtml.HTMLDocumentClass)axWebBrowser1.Document;
command cmd = (command)al[cmdNum];
switch (cmd.ElementType)
{
case "InputText":
{
mshtml.HTMLInputTextElement element = (mshtml.HTMLInputTextElement)doc.all.item(cmd.ElementId,0);
element.focus();//文本框获取焦点
SendKeys.Send(cmd.CommandString);//模似键盘打字
break;
}
case "submit":
{
mshtml.HTMLInputButtonElement element = (mshtml.HTMLInputButtonElement)doc.all.item(cmd.ElementId,0);
element.focus();
SendKeys.Send(cmd.CommandString);//提交表单后，计时器关闭，等页面加载完后开启
cmdNum++;
timer1.Enabled=false;
return;

}
case "button":
{
mshtml.HTMLInputButtonElement element = (mshtml.HTMLInputButtonElement)doc.all.item(cmd.ElementId,0);
element.focus();
SendKeys.Send(cmd.CommandString);
break;
}
cmdNum++;
timer1.Enabled=true; //计时器开启

}以上是基本方法，但会有一些问题
执行js脚本
(mshtml.HTMLDocumentClass)axWebBrowser1.Document.parentWindow.execScript("alert()","javascript")
如果希望网页不会有alert,confirm,脚本报错等，可以使用下面的js脚本
window.alert=function(){}; window.confirm=function(){return true}; window.onerror=function(){return true};
屏蔽弹屏
private void axWebBrowser1_NewWindow3(object sender, AxSHDocVw.DWebBrowserEvents2_NewWindow3Event e)
{
e.cancel=true;
}
弹屏在另一个webbrowers打开
private void axWebBrowser1_NewWindow2(object sender, AxSHDocVw.DWebBrowserEvents2_NewWindow2Event e)
{
e.ppDisp=axWebBrowser2.Application;
}
访问iframe
mshtml.IHTMLWindow2 farme = (mshtml.IHTMLWindow2)doc.frames.item(ref main);
这里很关键的地方是用IHTMLWindow2而不是用mshtml.HTMLIFrame如果你是做类库，那你不能有可视的界面，那你也不能模似键盘的操作了，你需要用SHDocVw.dll，这个文件在system32里面，提供和webbrowers一样的功能
public void openIE2()
{
Thread t=new Thread(new ThreadStart(threadOpenIE));
t.Name="changeorder";
t.Start(); //用多线程，这样可以并行打开多个网页
}
public void threadOpenIE()
{
object objFlags=0; //0无页面，有缓存 1有页面，无缓存
object objTargetFrameName="";
object objPostData="";
object objHeaders="User-Agent: Mozilla/4.0(compatible; MSIE 6.0; Windows NT 5.0)"; //可不写
SHDocVw.InternetExplorerClass a;
try
{
a=new SHDocVw.InternetExplorerClass();
}
catch(Exception e)
{
a=null;
throw e;
System.Threading.Thread.CurrentThread.Abort();
}
a.Navigate("http://host/action/HTMLPage1.asp",ref objFlags,ref objTargetFrameName,ref objPostData,ref objHeaders); //如果objFlags=0是不会弹出页面的，但可以把网页的dom对象保存在内存中，如果objFlags=1就会弹出ie,网页的内容也不会在内存中保存了
while (a.Busy);//不断访问页面直到页面加载结束.这里指服务器的响应，而不是js代码，也就是说再复杂的js代码也不会影响a.busy的状态
mshtml.HTMLDocumentClass doc=(mshtml.HTMLDocumentClass)a.Document;//如果objFlags=1就会报错
mshtml.HTMLSelectElementClass　selectelement = (mshtml.HTMLSelectElementClass)doc.all.item("reser_status",0);
selectelement.selectedIndex=2;//如果不知道index可以用selectelement.value="**";
object aaa=null;
selectelement.FireEvent("onchange",ref aaa);//因为无法模似键盘，所以页面上任何onchange类型js脚本无法运行，所以用FireEvent来激活onchange事件.
mshtml.HTMLInputTextElement textelement = (mshtml.HTMLInputTextElement)doc.all.item("price_admin",0);
textelement.value=textelement.value;
mshtml.HTMLInputButtonElement element = (mshtml.HTMLInputButtonElement)doc.all.item("su",0);
//这里如果网页很大，可以不会一次取到，要取多次
//for (int i = 0; i < times; i++)
// {
// if (Element == null)
// Element = doc.all.item(ElementName, index);
// else
// break;
// }
element.click();
while (a.Busy)
{
System.Threading.Thread.Sleep(500);//这样做可以减少访问页面的次数
}
while (a.ReadyState != SHDocVw.tagREADYSTATE.READYSTATE_COMPLETE)
{
System.Threading.Thread.Sleep(500);//a. busy等于fase的时候，页面也可能没有加载完，一定要有这步
}
doc=(mshtml.HTMLDocumentClass)a.Document;
string html=doc.body.innerHTML;
a.Quit();

System.Threading.Thread.CurrentThread.Abort();
}
也许有个会问为什么不用DocumentComplete事件，因为这个事件无非是又开一个线程进行监听，作为类库程序，主线程很容易执行完，释放资源，DocumentComplete执行完后将无法找到原来调用它的线程，如果一定要用的话可以这样用.
a.DocumentComplete+=new SHDocVw.DWebBrowserEvents2_DocumentCompleteEventHandler(a_DocumentComplete);
System.Threading.Thread.Sleep(3000);// 主线程等待为了使a_DocumentComplete可以执行，但做为类库项目不建议这样做，我们可以发现一般需要监听其它资源的事件都是新开线程，当事件激活后，回调方法时，主线程应确保还在内存中存在.
多线程使用SHDocVw.dll会丧失很多功能，比如doucment里面的parentwindow,iframe,script等属性可以访问不到.
调用com组件有一个不好就是很多错误都是未指定错误，所以你不知道是因为什么出的错.看错误可以看comException类的hresult属性，com组件报的错都是个数字，可惜的是，很多数字微软都说成未指定错误.
关闭窗口方法
browers.quit();
用javascript方法
doc.parentWindow.opener=null;
doc.parentWindow.open("","_top","",false);
doc.parentWindow.close();
对于很多页面元素的操作，没有什么资料，完全靠试，比如遍历某个select的option
mshtml.HTMLSelectElementClass dd=(mshtml.HTMLSelectElementClass)doc.all.item("ddd",0);
mshtml.IHTMLElementCollection aaa= (mshtml.IHTMLElementCollection)dd.children;
//这里试了半天才试出来，HTMLSelectElementClass.options HTMLSelectElementClass.childnodes 都没有办法转化为IHTMLElementCollection　
如果是option集合，不要想利用IHTMLElementCollection.item(name,index)的方法遍历，因为option是没有name的，如果试图采用IHTMLElementCollection.item(null,index)不管你index是几，返回结果都是第一个元素.
要用foreach
foreach(mshtml.HTMLOptionElementClass option in aaa)
{
string sd= option.value+option.text;
}
不过好像并不是所有的集合都可以foreach,不过在这里是可以用的
new一个SHDocVw.InternetExplorerClass();系统里面就会多一个iexplorer进程，记住一定要quit掉，用单例模式性能应该高点.

C# 通过IE句柄获得 IE Document对象和IWebBrowser2对象

58599886@qq.com(▄︻┳一) — Fri, 25 Sep 2009 04:59:34 GMT

本来是做JAVA的，由于工作需要，最近做了一些C# 对网页的控制，
一直以来都是利用System.Windows.Forms.WebBrowser webBrowser1 来把网页嵌入到我的窗体内进行控制。而且控制起来非常方便。
有一个项目的网页比较特殊，目前我还不知道什么原因，他的网页会把我的程序挂起，没办法，只有利用跨进程获得IE对象了。
主要应用了一个COM组件三个引用三个对象来讲述这个简单的例子
1.COM组件 Microsoft.mshtml.dll 这个不用多说了，地球人都知道。
2. using mshtml;//这。。。。。多说无用
　　using SHDocVw; //IWebBrowser2 是他下面的
using System.Runtime.InteropServices; //DLL的引用，方法的重写3.IWebBrowser2 其实他要比WebBrowser 强大的多，正常我们直接用内嵌的浏览器对象，如果深入的朋友，在应用内嵌浏览器的时候也可以使用它来接受对象。
IShellWindows 呵呵。。。自己追踪下就知道了。。都不用查
HTMLDocumentClass 这个本人也不求甚解，只知道他和 HTMLDocument差不多，只是方法名不太一样。。。
//---------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using mshtml;
using SHDocVw;
using System.Runtime.InteropServices;namespace dxzj
{
public partial class Form1 : Form
{
[DllImport("user32", EntryPoint = "FindWindow")]
public static extern int FindWindowA(string lpClassName, string lpWindowName);
public Form1()
{
InitializeComponent();
} private void timer1_Tick(object sender, EventArgs e)
{ }
//声明Document对象（如果用内嵌浏览器，我们得到的是一个HTMLDocument）
HTMLDocumentClass document = null;
private void button1_Click(object sender, EventArgs e)
{
//查找打开的窗口句柄
int iehwnd = FindWindowA(null, "用银行卡充值_中国联通 - Microsoft Internet Explorer");
//初始化所有IE窗口
IShellWindows sw = new ShellWindowsClass();
//轮询所有IE窗口
for (int i = sw.Count - 1; i >= 0; i--)
{
//得到每一个IE的 IWebBrowser2 对象
IWebBrowser2 iwb2 = sw.Item(i) as IWebBrowser2;
//比对得到的句柄是否符合查找的窗口句柄
if(iwb2.HWND == iehwnd)
{
//查找成功进行赋值
document = (HTMLDocumentClass)iwb2.Document;
//对网页进行操作
document.getElementById("directOnlinePayInfo.productNO").innerText = "1111";
}
}
}
}
}

C#中直接操作C++结构体

58599886@qq.com(▄︻┳一) — Thu, 10 Sep 2009 06:36:14 GMT

在C#中调用C++或系统DLL是比较常见的操作。
　　例如C++中定义的以下结构体：
struct RCEStruct {
int Event;
int Flag;
char User[40];
};　　同时有一个公开方法：
　　extern "C" __declspec WORD CALLBACK GetStruct(RCEStruct* pEventStruc);
　　我们将它编译为 MyCppDll.DLL

　　那么我们在C#中可以直接定义相同的结构体和引用GetStruct:
[StructLayout(LayoutKind.Sequential)]
public struct RCEStruct {
public int Event;
public int Flag;
public char[40] User;
}

[DllImport("MyCppDll.dll", CharSet=CharSet.Auto)]
public static extern int GetStruct(RCEStruct rce);
　　注意C#里定义的结构体应该和C++里定义的一样。这里如果是public string User就有可能出错(具体我没试过，不知道C#是否会自动将char[]转变为string，另外还要注意，在C#中为User赋值时，长度不应超过40)。
　　通过这种方式我们就可以向C++传递或者获得结构体。但一个限制就是必须在C#端主动调用GetStruct()

　　还有一种情况，与上一种相反，就是我们不是希望在C#中调用C++类库，而是想在C++类库中调用我们已经写好的C#类库。这在托管C++里是可以实现的。其中一个应用案例就是在为第三方系统写C++插件的时候，我们必须在插件端主动调用C#类库（前提是我们需要使用它，除非我们完全用C++代码来写这个插件）。
　　这样的话我们应该是在C#类库公开方法，例如：
public struct RCEStruct {
public int Event;
public int Flag;
public string User;
}

public void DoSomething(RCEStruct rce){
rce.Flag++;
}　　假定编译成 MyCSharpDll.DLL
　　C++端代码如下：
#using
#using

void SomeMethod(RCEStruct* pEventStruc){
// 将C++结构体赋值到C#结构体
MyCSharpDll::RCEStruct* csStruct;
csStruct->Event = pEventStruc.Event;
csStruct->Flag = pEventStruc.Flag;
// csStruct->User ?? 将char转换成string，在C++里如何处理？

MyCSharpDll::DoSomething(csStruct);

// 将C#结构体赋值到C++结构体
// 因为 pEventStruc 由外界传入，被 DoSomething 方法修改后，可能仍需要外界知道
pEventStruc->Event = csStruct.Event;
pEventStruc->Flag = csStruct.Flag;
// pEventStruc->User ?? 将string转换成char[]
}　　托管C++在处理.NET类库时，有些细节是很繁琐的，让人觉得有些晕乎。譬如很多地方要加__gc修饰符。还有像数组，字符串的转换都比较麻烦。所以上面代码可能会有些小错误。但大致意思就是这样。很明显，这样的做法非常麻烦。对结构体进行操作前，我们进行一次赋值，操作后，又进行一次赋值。
　　有没有办法直接让C#操作原始的结构体呢？就像C#中操作C++一样，不需要通过一个中间人？能不能直接这样：
#using
#using

void SomeMethod(RCEStruct* pEventStruc){
MyCSharpDll::DoSomething(pEventStruc);
}　　答案是否定的。我们没有办法直接将C++里的 RCEStruct转换为 C#里的 RCEStruct。

　　那么还剩一种方法，就是直接对内存进行操作。因为是结构体，他们肯定是保存在连续内存空间中的。
　　我们先来看看C#中如何操作内存，也就是非托管的数据。这需要引用System.Runtime.InteropServices命名空间。该命名空间下的Marshal的一些静态方法提供了这样的功能：
Marshal.ReadInt32() //从指定内存地址读取4位
Marshal.PtrToStringAnsi() //从指定内存地址读取字符串
Marshal.WriteInt32() //将整数写到指定内存地址
Marshal.WriteByte() //将字符串写到指定内存地址　　我们来看看具体的代码：
using System;
using System.Text;
using System.Runtime.InteropServices;

internal sealed class RCEvent {
public int Event;
public int Flag;
public string User;
};

internal sealed class RCEventAgent {
internal static RCEvent Read(IntPtr ptr){
RCEvent Event = new RCEvent();

Event.Event = ReadEvent(ptr);
Event.Flag = ReadFlag(ptr);
Event.User = ReadUser(ptr);

return Event;
}

internal static int ReadEvent(IntPtr basePtr) {
return Marshal.ReadInt32(basePtr);
}
internal static int ReadFlag(IntPtr basePtr) {
return Marshal.ReadInt32(basePtr,4);
}
internal static string ReadUser(IntPtr basePtr) {
return Marshal.PtrToStringAnsi(new IntPtr(basePtr.ToInt32() + 8));
}

internal static void Write(ClientEvent Event,IntPtr ptr) {
WriteEvent(ptr,Event.Event);
WriteFlag(ptr,Event.Flag);
WriteUser(ptr,Event.User);
}

internal static void WriteEvent(IntPtr basePtr,int value) {
Marshal.WriteInt32(basePtr,value);
}
internal static void WriteFlag(IntPtr basePtr,int flag) {
Marshal.WriteInt32(basePtr,4,flag);
}
internal static void WriteUser(IntPtr basePtr,string user) {
WriteString(basePtr,user,8,40);
}
private static void WriteString(IntPtr basePtr,string value,int offset,int length) {
int pos = 0;
byte[] bytes = Encoding.Default.GetBytes(value);
while(pos < length) {
if (pos < bytes.Length)
Marshal.WriteByte(basePtr,offset,bytes[pos]);
else
Marshal.WriteByte(basePtr,offset,0);

pos ++;
offset ++;
}
}
}　　这样我们就可以通过ReadEvent和WriteEvent直接在c#中处理该结构体。或者通过 ReadXXX() 和 WriteXXX() 直接修改其字段。
public void DoSomething(IntPtr ptr){
RCEvent Event = RCEventAgent.Read(ptr);
Event.Flag ++;
RCEventAgent.Write(ptr, Event);

// 或者以下代码
// RCEventAgent.WriteFlag( ptr, RCEventAgent.ReadFlag(ptr) + 1 );
}　　C++中则可以直接将结构体地址传给C#：
#using
#using

void SomeMethod(RCEStruct* pEventStruc){
MyCSharpDll::DoSomething(pEventStruc);
}

C#调用C++写的dll，包含结构体转换和C#动态调用dll

58599886@qq.com(▄︻┳一) — Thu, 10 Sep 2009 06:18:23 GMT

这段时间用C++给客户做了一个通讯的dll。但客户是用C#的，所以研究了下C#，把C++的头文件，改写成C#的。主要是转换了结构体的定义，dll函数的调用，C#中的dll的动态调用，C++和C#之间的时间变量的传递。现在和大家分享一下。

C++的头文件：

#pragma once
//
//设置
//
typedef struct _RMusterSettings
{
DWORD dwDataSize;
RComm Comm;
RCoData CoData;
double RealClock;
WORD MeterCount;
WORD RecNoMax;
struct _RAutoReadSettings
{
BYTE Enable;
BYTE Days[31];
struct _RARTime
{
BYTE Enable;
BYTE Hour;
BYTE Min;
BYTE Sec;

}Time[24];
} RAutoReadSettings;
} RMusterSettings;
//
//通讯类定义
//
typedef HANDLE (*CREATEXXXXCOMM)();
typedef INT (*FREEXXXXCOMM)(HANDLE);
typedef INT (*XXXXCOMM)(HANDLE,WORD,void *);
typedef INT (*XXXXABORT)(HANDLE);
class CXXXXComm
{
private:
HINSTANCE hLib;
HANDLE hXXXXComm;
CREATEXXXXCOMM fnCreateXXXXComm;
FREEXXXXCOMM fnFreeXXXXComm;
XXXXCOMM fnXXXXComm;
XXXXABORT fnXXXXAbort;
public:
CXXXXComm(PCHAR fileName)
{
hLib = LoadLibrary(fileName);
if (hLib != NULL)
{
fnCreateXXXXComm = (CREATEXXXXCOMM) GetProcAddress(hLib, "CreateXXXXComm");
fnFreeXXXXComm = (FREEXXXXCOMM) GetProcAddress(hLib, "FreeXXXXComm");
fnXXXXComm = (XXXXCOMM) GetProcAddress(hLib, "XXXXComm");
fnXXXXAbort = (XXXXABORT) GetProcAddress(hLib, "XXXXAbort");
hXXXXComm = fnCreateXXXXComm();
}
};
~CXXXXComm()
{
if (hLib != NULL)
{
fnFreeXXXXComm(hXXXXComm);
FreeLibrary(hLib);
}
};
INT Comm(WORD cmd, void * data)
{
if (hLib != NULL)
return fnXXXXComm(hXXXXComm,cmd,data);
else
return EC_DLL_NOT_FOUND;
};
INT Abort()
{
if (hLib != NULL)
return fnXXXXAbort(hXXXXComm);
else
return 0;
};
};

C#的类文件

using System;
using System.Runtime.InteropServices;
namespace Flagele.rd.CXXXXComm
{
//
//设置
//
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct RARTime
{
public byte Enable;
public byte Hour;
public byte Min;
public byte Sec;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct RAutoReadSettings
{

public byte Enable;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 31)]
public byte[] Days;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 24)]
public RARTime[] Time;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public class RMusterSettings
{
public uint dwDataSize;
public RComm Comm;
public RCoData CoData;
//
public long RealClock;
public ushort MeterCount;
public ushort RecNoMax;
public RAutoReadSettings ARSettings;
}
//
//通讯类
//
public class CXXXXComm
{
private uint hLib;
private uint hXXXXComm;
private delegate uint CREATEXXXXCOMM();
private delegate uint FREEXXXXCOMM(uint hFe);
private delegate uint XXXXCOMM(uint hFe, ushort cmd, [In,Out,MarshalAs(UnmanagedType.AsAny)] Object data);
private delegate uint XXXXABORT(uint hFe);
private CREATEXXXXCOMM fnCreateXXXXComm;
private FREEXXXXCOMM fnFreeXXXXComm;
private XXXXCOMM fnXXXXComm;
private XXXXABORT fnXXXXAbort;
[DllImport("Kernel32")]
private static extern uint GetProcAddress(uint handle, String funcname);
[DllImport("Kernel32")]
private static extern uint LoadLibrary(String funcname);
[DllImport("Kernel32")]
private static extern uint FreeLibrary(uint handle);
private static Delegate GetAddress(uint dllModule, string functionname, Type t)
{
uint addr = GetProcAddress(dllModule, functionname);
if (addr == 0)
return null;
else
return Marshal.GetDelegateForFunctionPointer(new IntPtr(addr), t);
}
public CXXXXComm()
{
hLib = LoadLibrary("XXXXComm.dll");
if (hLib != 0)
{
fnCreateXXXXComm = (CREATEXXXXCOMM)GetAddress(hLib, "CreateXXXXComm", typeof(CREATEXXXXCOMM));
fnFreeXXXXComm = (FREEXXXXCOMM)GetAddress(hLib, "FreeXXXXComm", typeof(FREEXXXXCOMM));
fnXXXXComm = (XXXXCOMM)GetAddress(hLib, "XXXXComm", typeof(XXXXCOMM));
fnXXXXAbort = (XXXXABORT)GetAddress(hLib, "XXXXAbort", typeof(XXXXABORT));
if (fnCreateXXXXComm != null)
{
hXXXXComm = fnCreateXXXXComm();
}
}
}
~CXXXXComm()
{
if (fnFreeXXXXComm != null)
{
fnFreeXXXXComm(hXXXXComm);
}
if (hLib != 0)
{
FreeLibrary(hLib);
}
}
public uint comm(ushort cmd, [MarshalAs(UnmanagedType.AsAny)] Object data)
{
if (hLib != 0)
{
return fnXXXXComm(hXXXXComm, cmd, data);
}
else
return CFeError.EC_DLL_NOT_FOUND;
}
public uint abort()
{
if (hLib != 0)
{
return fnXXXXAbort(hXXXXComm);
}
else
return 0;
}
}
}

C#的调用例子
//事先要创建XXXXComm//private CXXXXComm XXXXComm;//public Form1()//{// InitializeComponent();// XXXXComm= new CXXXXComm();//}////▼写设置// mustersettings.ARSettings.Enable = 1; for (i = 0; i < 31; i++) mustersettings.ARSettings.Days = 1; for (i = 0; i < 24; i++) { mustersettings.ARSettings.Time.Enable = 0; mustersettings.ARSettings.Time.Hour = (byte)i; mustersettings.ARSettings.Time.Min = 0; mustersettings.ARSettings.Time.Sec = 0; } Rec = XXXXComm.comm(CFeCmd.W_MusterAutoRead,(Object)mustersettings); if (Rec == 0) { //成功 }

C#中调用带回调函数和自定义结构体的DLL例程

58599886@qq.com(▄︻┳一) — Thu, 10 Sep 2009 06:13:20 GMT

开发环境: WinXP Pro(SP2英文版) + VS.NET 2003中文版
接口库版本: CMPP2.0 API第二版(V2.6)
该例程演示了如何在C#里面调用VC6.0开发的带回调函数的API，而且回调函数的参数包含结构体，使用C#的委托和IntPtr方法实现.
由于我使用C#刚两天,这是我写的第一个C#程序,因此例程写的可能有点粗糙,但是编译和运行完全没有问题.
CMPP2.0的API封装成了标准C调用的方法，提供以下三个接口，使用的时候只要有CMPPAPI.dll就可以了.
#define DllExport extern "C" __declspec(dllexport)
DllExport int __stdcall Cmpp2Start(LPCTSTR pchSmgIp, int nMtPort, int nMoPort, \
LPCTSTR pchUserName, LPCTSTR pchUserPwd, unsigned char uchVersion, \
void (__stdcall *OnSmgMsg)(CMPP_SMGTOSP* css), int nConnType, void (__stdcall *OnLogFile)(LPCTSTR str));
DllExport int __stdcall Cmpp2Submit(unsigned char uchPKtotal, unsigned char uchPKnumber, \
unsigned char uchNeedreport, unsigned char uchMsglevel, LPCTSTR pchServiceid, \
unsigned char uchFeeusertype, LPCTSTR pchFeeterminalid, unsigned char uchTppid, \
unsigned char uchTpudhi, unsigned char uchMsgfmt, LPCTSTR pchMsgsrc, \
LPCTSTR pchFeetype, LPCTSTR pchFeecode, LPCTSTR pchValidtime, \
LPCTSTR pchAttime, LPCTSTR pchSrcid, unsigned char uchDestusrtl, \
LPCTSTR pchDestterminalid, unsigned char uchMsglen, LPCTSTR pchMsgcontent);
DllExport int __stdcall Cmpp2Release();
在C#里面如何调用API,如何声明结构体,如何使用委托实现回调函数,如何实现使用自定义结构体作为参数的回调函数,请仔细查看例程源码。注意:CMPPAPI.dll要和可执行文件放到同一个目录下,或者放到可执行文件能找到的目录,或者放到系统目录下(如:C:\windows\system32).
下面是C#下面的完整的调用代码//Class1.cs
using System;
// 该名称空间包含了在Visual C#中调用API的一些必要集合
using System.Runtime.InteropServices;
// 使用Sleep方法需要的命名空间
using System.Threading;namespace CMPPAPI_Sample_CSharp
{
//---------------------------------------------------------------------
//---------以下是DLL中需要使用的结构体的定义---------------------------
//--------Pack = 1表示结构体按一个字节对齐----------------------------
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_HEAD
{
public uint nTotalLength;
public uint nCommandId;
public uint nSeqId;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_CONNECT
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 6)]
public string sSourceAddr;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
public string sAuthSource;
public byte cVersion;
public uint nTimeStamp;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_CONNECT_RESP
{
public byte uchStatus;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
public string sAuthISMG;
public byte cVersion;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_SUBMIT_RESP
{
public long nMsgid;
public byte uchResult;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_STATUS_REPORT
{
public long nMsgid;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 7)]
public string sStat;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
public string sSubmitTime;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
public string sDoneTime;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21)]
public string sDestTerminalId;
public uint nSmscSeq;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_MO_MSGCONTENT
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 160)]
public string sMsgcontent;
public CMPP_STATUS_REPORT csr;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_DELIVER
{
public long nMsgid;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21)]
public string sDestid;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
public string sServiceid;
public byte uchTppid;
public byte uchTpudhi;
public byte uchMsgfmt;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21)]
public string sSrcterminalid;
public byte uchRegisteredDelivery;
public byte uchMsglength;public CMPP_MO_MSGCONTENT mo_msg;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string sReserved;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_SUBMIT
{
public long nMsgid;
public byte uchPkTotal;
public byte uchPkNumber;
public byte uchRegisteredDelivery;
public byte uchMsgLevel;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
public string sServiceId;
public byte uchFeeUserType;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21)]
public string sFeeTerminalId;
public byte uchTpPid;
public byte uchTpUdhi;
public byte uchMsgFmt;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 6)]
public string sMsgSrc;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 2)]
public string sFeeType;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 6)]
public string sFeeCode;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 17)]
public string sValidTime;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 17)]
public string sAtTime;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21)]
public string sSrcId;
public byte uchDstUsrTl;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 21*100)]
public string sDstTerminalId;
public byte uchMsgLength;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 160)]
public string sMsgContent;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string sReserved;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_QUERY
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string sTime;
public byte uchQueryType;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
public string sQueryCode;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string sReserved;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_QUERY_RESP
{
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string sTime;
public byte uchQueryType;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)]
public string sQueryCode;
public uint nMTTLMsg; //从SP接收消息总数.
public uint nMTTLUsr; //从SP接收用户总数.
public uint nMTScs; //成功转发数量.
public uint nMTWT; //待转发数量.
public uint nMTFL; //转发失败数量.
public uint nMOScs; //向SP成功送达数量.
public uint nMOWT; //向SP待送达数量.
public uint nMOFL; //向SP送达失败数量.
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_CANCEL
{
public long nMsgid;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_CANCEL_RESP
{
public byte uchSuccessId;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_ACTIVETEST_RESP
{
public byte uchReserved;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_BODY
{
public CMPP_CONNECT_RESP pk_connectresp;
public CMPP_SUBMIT_RESP pk_submitresp;
public CMPP_QUERY_RESP pk_queryresp;
public CMPP_DELIVER pk_deliver;
public CMPP_CANCEL_RESP pk_cancelresp;
public CMPP_ACTIVETEST_RESP pk_activetestresp;
}[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct CMPP_SMGTOSP
{
public CMPP_HEAD pk_head;
public CMPP_BODY pk_body;
}
//----------------DLL需要使用的结构体的定义----------------------------
//---------------------------------------------------------------------
//----------------声明两个委托,相当于VC里面的回调函数------------------
public delegate void OnSmgMsg(IntPtr css);
public delegate void OnLogMsg(string str);
//---------------------------------------------------------------------class Class1
{
//--------------------------------------------------------------------------
//--------------DLL中的API函数声明------------------------------------------
// 1.Start Func
[DllImport("CMPPAPI.dll")]
public static extern int Cmpp2Start(string pchSmgIp, int nMtPort, int nMoPort,
string pchUserName, string pchUserPwd, byte uchVersion,
OnSmgMsg pf, int nConnType, OnLogMsg pf2);// 2.Submit Func
[DllImport("CMPPAPI.dll")]
public static extern int Cmpp2Submit(byte uchPKtotal, byte uchPKnumber,
byte uchNeedreport, byte uchMsglevel, string pchServiceid,
byte uchFeeusertype, string pchFeeterminalid, byte uchTppid,
byte uchTpudhi, byte uchMsgfmt, string pchMsgsrc,
string pchFeetype, string pchFeecode, string pchValidtime,
string pchAttime, string pchSrcid, byte uchDestusrtl,
string pchDestterminalid, byte uchMsglen, string pchMsgcontent);// 3.Release
[DllImport("CMPPAPI.dll")]
public static extern int Cmpp2Release();
//--------------DLL中的API函数声明------------------------------------------
//--------------------------------------------------------------------------//-------------这儿使用IntPtr实现与结构体之间的转换----------------
public static void OnMsg(IntPtr ptr)
{
CMPP_SMGTOSP css = new CMPP_SMGTOSP();
css = (CMPP_SMGTOSP)Marshal.PtrToStructure(ptr, typeof(CMPP_SMGTOSP));uint nCmdId = css.pk_head.nCommandId;
Console.WriteLine(css.pk_head.nCommandId);
if ( nCmdId == 0x80000004) {
// Submit应答消息
}
else if ( nCmdId == 0x0000005) {
// Deliver消息
}return;
}//------------第二个委托函数的定义-------------------------------
public static void OnLog(string str)
{
Console.WriteLine(str);
return;
}///
/// 应用程序的主入口点。
///
[STAThread]
static void Main(string[] args)
{
Class1 c1 = new Class1();
OnSmgMsg pt = new OnSmgMsg(OnMsg);
OnLogMsg pLog = new OnLogMsg(OnLog);//-------------启动模块,连接网关,收到消息以后会触发OnSmgMsg函数------------------------------
int nRetCode = Cmpp2Start("127.0.0.1", 7890, 7891, "901234", "1234", (byte)0x20, pt, 0, pLog);
if ( 0 == nRetCode)
{
Console.WriteLine("Connect Smg success\n");while ( true)
{
//----------向网关提交Submit消息----------
nRetCode = Cmpp2Submit(1, 1,
1, 3, "2939",
0, "", 0,
0, 0, "901234",
"02", "000020", "",
"", "01850", 1,
"8613660617374", 8, "测试消息");if ( 0 == nRetCode)
{
Console.WriteLine("Submit Success.");
}
else {
Console.WriteLine("Submit Fail.");
}// Sleep5秒钟
Thread.Sleep(5000);
}//-----释放连接-----
Cmpp2Release();
}
else {
Console.WriteLine("Connect SMG Fail With Error: " + nRetCode);
}
}
}
}

《Effective C#》学习笔记（六）--C#和C++结构体Socket通信

58599886@qq.com(▄︻┳一) — Thu, 10 Sep 2009 06:09:40 GMT

Socket发送消息的时候遇到了服务端需要接收C++结构体的二进制数据流，这个时候就需要用C#仿照C++的结构体做出一个结构来，然后将其转换成二进制流进行发送，之后将响应消息的二进制数据流转换成C#结构。
1、仿照C++结构体写出C#的结构来
1 using System.Runtime.InteropServices;
2
3 [Serializable] // 指示可序列化
4 [StructLayout(LayoutKind.Sequential, Pack = 1)] // 按1字节对齐
5 public struct Operator
6
7 {
8 public ushort id;
9 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 11)] // 声明一个字符数组，大小为11
10 public char[] name;
11 [MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)]
12 public char[] pass;
13
14 public Operator(string user, string pass) // 初始化
15 {
16 this.id = 10000;
17 this.name = user.PadRight(11, '\0').ToCharArray();
18 this.pass = pass.PadRight(9, '\0').ToCharArray();
19 }
20 }
2、注意C#与C++数据类型的对应关系
C++与C#的数据类型对应关系表
API数据类型类型描述 C#类型 API数据类型类型描述 C#类型
WORD 16位无符号整数 ushort CHAR 字符 char
LONG 32位无符号整数 int DWORDLONG 64位长整数 long
DWORD 32位无符号整数 uint HDC 设备描述表句柄 int
HANDLE 句柄,32位整数 int HGDIOBJ GDI对象句柄 int
UINT 32位无符号整数 uint HINSTANCE 实例句柄 int
BOOL 32位布尔型整数 bool HWM 窗口句柄 int
LPSTR 指向字符的32位指针 string HPARAM 32位消息参数 int
LPCSTR 指向常字符的32位指针 String LPARAM 32位消息参数 int
BYTE 字节 byte WPARAM 32位消息参数 int
整个结构的字节数是22bytes。
对应的C++结构体是：
1 typedef struct
2{
3 WORD id;
4 CHAR name[11];
5 CHAR password[9];
6 }Operator;
3、发送的时候先要把结构转换成字节数组
1 using System.Runtime.InteropServices;
2 ///

4 /// 将结构转换为字节数组
5 ///

6 /// 结构对象
7 /// 字节数组
8 public byte[] StructToBytes(object obj)
9 {
10 //得到结构体的大小
11 int size = Marshal.SizeOf(obj);
12 //创建byte数组
13 byte[] bytes = new byte[size];
14 //分配结构体大小的内存空间
15 IntPtr structPtr = Marshal.AllocHGlobal(size);
16 //将结构体拷到分配好的内存空间
17 Marshal.StructureToPtr(obj, structPtr, false);
18 //从内存空间拷到byte数组
19 Marshal.Copy(structPtr, bytes, 0, size);
20 //释放内存空间
21 Marshal.FreeHGlobal(structPtr);
22 //返回byte数组
23 return bytes;
24
25 }
26
27
接收的时候需要把字节数组转换成结构

1 //

2 /// byte数组转结构
3 ///

4 /// byte数组
5 /// 结构类型
6 /// 转换后的结构
7 public object BytesToStruct(byte[] bytes, Type type)
8 {
9 //得到结构的大小
10 int size = Marshal.SizeOf(type);
11 Log(size.ToString(), 1);
12 //byte数组长度小于结构的大小
13 if (size > bytes.Length)
14 {
15 //返回空
16 return null;
17 }
18 //分配结构大小的内存空间
19 IntPtr structPtr = Marshal.AllocHGlobal(size);
20 //将byte数组拷到分配好的内存空间
21 Marshal.Copy(bytes, 0, structPtr, size);
22 //将内存空间转换为目标结构
23 object obj = Marshal.PtrToStructure(structPtr, type);
24 //释放内存空间
25 Marshal.FreeHGlobal(structPtr);
26 //返回结构
27 return obj;
28 }
29
4、实际操作：

1 using System.Collections;
2 using System.Collections.Generic;
3 using System.Net;
4 using System.Net.Sockets;
5
6 byte[] Message = StructToBytes(new Operator("user","pass")); // 将结构转换成字节数组
7
8 TcpClient socket = new TcpClient();
9
10 socket.Connect(ip,port);
11
12 NetworkStream ns = Socket.GetStream();
13
14 ns.Write(Message,0,Message.Length); // 发送
15
16 byte[] Recv = new byte[1024]; // 缓冲
17
18 int NumberOfRecv = 0;
19
20 IList newRecv = new List();
21 ns.ReadTimeout = 3000;
22 try
23 {
24 do
25 {
26 // 接收响应
27 NumberOfRecv = ns.Read(Recv, 0, Recv.Length);
28 for (int i = 0; i < NumberOfRecv; i++)
29 newRecv.Add(Recv);
30 }
31 while (ns.DataAvailable);
32 byte[] resultRecv = new byte[newRecv.Count];
33 newRecv.CopyTo(resultRecv, 0);
34
35 Operator MyOper = new Operator();
36
37 MyOper = (Operator)BytesToStruct(resultRecv, MyOper.GetType()); // 将字节数组转换成结构
38
在这里取值的时候可能会出现只能取到一个字段，剩余的取不到的问题，怎么回事我也搞不懂，反正我的解决办法就是按照字节的顺序从resultRecv里分别取出对应的字段的字节数组，然后解码，例如：
Operator.name是11个字节，最后一位是0，Operator.id是2个字节，那么从第3位到第12位的字节就是Operator.name的内容，取出另存为一个数组MyOperName，Encoding.Default.GetString(MyOperName)就是MyOper.name的内容。
1 socket.Close();
2
3 ns.Close();
4本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/kaola2599/archive/2009/06/24/4294639.aspx

让人兴奋的新婚典礼

58599886@qq.com(▄︻┳一) — Mon, 31 Aug 2009 12:57:20 GMT

[转]某高校寝室熄灯的壮观景象!!

58599886@qq.com(▄︻┳一) — Mon, 31 Aug 2009 12:02:17 GMT

这张帖你能忍住不转？？太牛了！！

壮观得不得了...不知道演练了多少次~~~!
呵呵~~~
------------------------------------------
本文转载自：冯志锦：某高校寝室熄灯的壮观景象!!
用QQ邮箱阅读空间订阅冯志锦
什么是阅读空间?
------------------------------------------
本文转载自：-陳冭冭：转载：某高校寝室熄灯的壮观景象!!
用QQ邮箱阅读空间订阅-陳冭冭
什么是阅读空间?

在C#中使用SendMessage

58599886@qq.com(▄︻┳一) — Sun, 30 Aug 2009 12:18:17 GMT

SendMessage是一个在user32.dll中声明的API函数，在C#中导入如下：

using System.Runtime.InteropServices;
[DllImport("user32.dll", EntryPoint="SendMessageA")]
public static extern int SendMessage (IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);
本文描述其参数 lParam 的用法，主要是数据类型之间的转化。

● 一种最简单的处理方式是声明多个SendMessage函数(overload)，用所需的数据类型直接替换IntPtr。例如：

//声明:
[DllImport("user32.dll", EntryPoint="SendMessageA")]
private static extern int SendMessage (IntPtr hwnd, int wMsg, IntPtr wParam, string lParam);
[DllImport("user32.dll", EntryPoint="SendMessageA")]
private static extern int SendMessage (IntPtr hwnd, int wMsg, IntPtr wParam, ref Rectangle lParam);
//调用:
string s = "hello, floodzhu";
SendMessage(this.textBox1.Handle, WM_SETTEXT, IntPtr.Zero, s);

Rectangle rect = new Rectangle();
SendMessage(this.richTextBox1.Handle, EM_GETRECT, (IntPtr)0, ref rect);
● 对要求返回字符串的类型（out string）可以用 StringBuilder 代替，此时不需要 out/ref。例如：

[DllImport("user32.dll", EntryPoint="SendMessageA")]
private static extern int SendMessage (IntPtr hwnd, int wMsg, int wParam, StringBuilder lParam);
private void button1_Click(object sender, System.EventArgs e)
{
const int buffer_size = 1024;
StringBuilder buffer = new StringBuilder(buffer_size);
SendMessage(this.textBox1.Handle, WM_GETTEXT, buffer_size, buffer);
//MessageBox.Show(buffer.ToString());
}
● 如果想用 InPtr 类型统一处理的话，可以借助于 Marshal 或者 GCHandle 的相关方法。例如：

[DllImport("user32.dll", EntryPoint="SendMessageA")]
private static extern int SendMessage (IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);

private void button2_Click(object sender, System.EventArgs e)
{
Rectangle rect = new Rectangle();
IntPtr buffer = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Rectangle)));
Marshal.StructureToPtr(rect, buffer ,true);

SendMessage(this.richTextBox1.Handle, EM_GETRECT, (IntPtr)0, buffer);

rect = (Rectangle)Marshal.PtrToStructure(buffer, typeof(Rectangle));

Marshal.FreeHGlobal(buffer);
}
或者

private void button2_Click(object sender, System.EventArgs e)
{
Rectangle rect = new Rectangle();
GCHandle gch = GCHandle.Alloc(rect);

SendMessage(this.richTextBox1.Handle, EM_GETRECT, (IntPtr)0, (IntPtr)gch);
rect = (Rectangle)Marshal.PtrToStructure((IntPtr)gch, typeof(Rectangle));

gch.Free();
}