一、c#结构体
 
1、定义与C++对应的C#结构体

 
在c#中的结构体不能定义指针，不能定义字符数组，只能在里面定义字符数组的引用。
C++的消息结构体如下：
//消息格式 4+16+4+4= 28个字节
struct cs_message
{
    u32_t        cmd_type;
    char username[16];
    u32_t        dstID;
    u32_t        srcID;
};
 
C#定义的结构体如下:
 
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct my_message
{
    public UInt32  cmd_type;

    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
    public string username;    

    public UInt32  dstID;

    public UInt32  srcID;

    public my_message(string s)
    {
        cmd_type = 0;
        username = s;
        dstID = 0;
        srcID = 0;
    }
}
 
在C++的头文件定义中，使用了 #pragma pack 1 字节按1对齐，所以C#的结构体也必须要加上对应的特
性，LayoutKind.Sequential属性让结构体在导出到非托管内存时按出现的顺序依次布局,而对于C++的
char数组类型，C#中可以直接使用string来对应，当然了，也要加上封送的特性和长度限制。

2、结构体与byte[]的互相转换
 
定义一个类，里面有2个方法去实现互转：
 
public class Converter
{
    public Byte[] StructToBytes(Object structure)
    {

        Int32 size = Marshal.SizeOf(structure);
        Console.WriteLine(size);
        IntPtr buffer = Marshal.AllocHGlobal(size);
        try
        {
            Marshal.StructureToPtr(structure, buffer, false);
            Byte[] bytes = new Byte[size];
            Marshal.Copy(buffer, bytes, 0, size);
            return bytes;
        }
        finally
        {
            Marshal.FreeHGlobal(buffer);
        }
    }

    public Object BytesToStruct(Byte[] bytes, Type strcutType)
    {
        Int32 size = Marshal.SizeOf(strcutType);
        IntPtr buffer = Marshal.AllocHGlobal(size);
        try
        {
            Marshal.Copy(bytes, 0, buffer, size);
            return Marshal.PtrToStructure(buffer, strcutType);
        }
        finally
        {
            Marshal.FreeHGlobal(buffer);
        }
    }
}
 
3、测试结果：
 
static void Main(string[] args)
{
    //定义转换类的一个对象并初始化
    Converter Convert = new Converter();

    //定义消息结构体
    my_message m;

    //初始化消息结构体
    m = new my_message("yanlina");
    m.cmd_type = 1633837924;
    m.srcID = 1633837924;
    m.dstID = 1633837924;

    //使用转换类的对象的StructToBytes方法把m结构体转换成Byte
    Byte[] message = Convert.StructToBytes(m);
    //使用转换类的对象的BytesToStruct方法把Byte转换成m结构体
    my_message n = (my_message)Convert.BytesToStruct(message, m.GetType());
    //输出测试
    Console.WriteLine(Encoding.ASCII.GetString(message));
    Console.WriteLine(n.username);
}
 
结构体的size是28个字节和c++的结构体一样，同时可以将结构体和字节数组互转，方便UDP的发送和接收。

本文来自CSDN博客，转载请标明出处：
http://blog.csdn.net/huxiangyang4/archive/2010/08/31/5853247.aspx

值传递：传的是对象的值拷贝。(即函数内参数对象是调用时传递的对象的栈中对象的拷贝。)
引用传递：传的是栈中对象的地址。(即函数内参数对象与调用时传递的对象完全是同一栈中对象。)
现在用例子来说明传值跟传地址的不同：

private void button2_Click(object sender, System.EventArgs e)
...{
  StringBuilder strb1 = new StringBuilder();
  StringBuilder strb2 = new StringBuilder();
  Test1(strb1);
  Test2(ref strb2);
  string str1 = strb1.ToString(); //str1值:"A"
  string str2 = strb2.ToString(); //str2值:"BC"
}

void Test1(StringBuilder strb)
...{
  //strb和strb1是两个栈中对象，但指向相同的地址，这个操作是改变堆中对象
  strb.Append("A");

  //这里将strb指向一个新的堆中对象，所以后面的操作与strb1指向的栈中对象无关
  strb = new StringBuilder("B");
  strb.Append("C");
}

void Test2(ref StringBuilder strb)
...{
  //这里的strb和strb2是同一个栈中对象，所以改变strb的值使其指向另一个对象也等于改变strb2
  strb = new StringBuilder("B");
  strb.Append("C");
}

常用的绘图方式，但是压缩算法太差，大图压缩失真严重，并且支持图片类型太少,支持bmp.
一些绘图方法参考另一文章:图片镂空算法集合

CxImage:

是一个开源库，功能强大，其官方主页http://www.xdp.it/cximage/
常用的5种:bmp,gif,png,jpg,ico
其他类型:tif,tga,pcx,wbmp,wmf,jp2,jpc,pgx,pnm,ras,jbg,mng,ska,raw
CxImage压缩算法较好，绘图速度快,4400*3000左右像素图片，容量3M左右，压缩到50*50，在快速拉动图片，并移动时，一点也不卡。

 VS7.1环境配置
 lib路径:在工程配置->连接器->常规->附加目录库
 加载lib:在工程配置->连接器->输入->附加依赖项
 cximage.lib
 jasper.lib
 jbig.lib
 Jpeg.lib
 png.lib
 Tiff.lib
 zlib.lib
 mng.lib
 libdcr.lib

 头文件路径:在工程配置c/c++->常规->附加包含目录
 使用：只需要包含"xImage.h"

 CxImage image;
 image.Load()，CreateFromHBITMAP()等函数导入图片
 image.Stretch(HDC,x,y,width,height);

GDI+:

同样功能强大，支持：bmp,jpg,gif,tiff,png.图片转换之前的算法应该是最好的，用大图去压缩，图片效果明显要比前两者好。
但是画大图时，速度太慢.比如以上4400*3000的图片，压缩到50*50,画图时间竟然是0.15秒，如果放在快速更新，或者移动的处理时，明显会延迟.

 使用前，需要在APP文件中初使化GDI+
 DWORD m_gdiplusToken;
 CGameApp::InitInstance()
 {
   Gdiplus::GdiplusStartupInput gdiplusStartupInput;
  Gdiplus::GdiplusStartup(&m_gdiplusToken, &gdiplusStartupInput, NULL);
 }
 int  CGameApp::ExistInstance()
 {
  Gdiplus::GdiplusShutdown(m_gdiplusToken);
  return 0;
 }

 Bitmap * pBmp = Bitmap::FromHBITMAP() 或者 Bitmap::FromFile() 等函数导入图片
 Graphics gr(HDC);
 gr.DrawImage(pBmp,x,y,Width,Height);

总结：

      1、一般绘图用GDI
      2、需要不同类型的图片格式，并且要快速绘图的用CxImage
      3、需要不同类型的图片格式，且要高质量图片效果的用GDI+

本文来自：http://blog.csdn.net/xuweiqun/archive/2009/07/20/4363627.aspx

首先说说什么类型是值类型，例如：int、float、bool之类的基础类型，以及用struct定义 的类型，如：DateTime。除此外，如 string，数组，以及用class定义的类型等都是引用类型。对于C#来说，很难罗列出所有类型进行一一分别，这需要自己在编码过程中进行分析总结。
 

       为了更好地说明两种类型之间的区别，借用如下的表格来说明:

  值类型 引用类型
内存分配地点 分配在栈中 分配在堆中
效率 效率高，不需要地址转换 效率低，需要进行地址转换
内存回收 使用完后，立即回收 使用完后，不是立即回收，等待GC回收
赋值操作 进行复制，创建一个同值新对象 只是对原有对象的引用
函数参数与返回值 是对象的复制 是原有对象的引用，并不产生新的对象
类型扩展 不易扩展 容易扩展，方便与类型扩展

通过如上细致对比，大家对于值类型和引用类型有个清楚的概念。

不过，无论是对于值类型还是引用类型来说，对于其作为函数参数或者返回值的时候，都是容易犯错误的地方。

对于值类型来说，当其 作为函数参数的时候，希望在函数中被修改，那么直接如下操作是不能被修改的:

public void Increment( int i )   
{   
　 i++;   
}  

要想在函数中对传进去的参数做真正的修改，需要借助于ref这个关键字，那么正确的形式如下:

public void Increment( ref int i )   
{   
　i++;   
}  

        也就是说，如果需要在函数中对值类型参数进行修改，需要用ref或者out进行标识才能真正实现。

而对于引用 类型来说，当其作为函数参数的时候，它所遇到的情况恰恰与值类型相反，即不希望在函数中被修改，举例如下:

public void AddValue( MyType typValue )   
{   
　typValue.Count = typValue.Count + 15;   
}  

         由于对于引用类型对象来说，其的赋值操作只是对原有对象的引用，因此在函数对其修改，实际上是直接修改了原有对象数据，这是很多 情况不希望发生的（这里例如对数组或者DataTable操作这类）。

为了防止这种事发生，需要给此类型提供clone函数。例如对 于如上的类型，可以入下实现 :

public class MyType:ICloneable   
{   
　private int nCount = 0;   
　public int Count   
　{   
　　set{ nCount = value;}   
　　get{ return nCount;}   
　}   
　public MyType()   
　{}   
　public MyType( int Value)   
　{   
　　nCount = Value;   
　}   
　#region ICloneable Members   
　public object Clone()   
　{   
　　// TODO: Add MyType.Clone implementation   
　　return new MyType( nCount );   
　}   
  
　#endregion   
}  

　     那么在调用的时候，用当前的对象的clone作为参数即可。

不过对于引用类型来说，提供一个clone函数不是一 件容易的事情，尤其出现引用类型嵌套的时候，所以说去实现一个完全clone功能是件很费事又不讨好的活，这也就是在论坛中常说的深copy和浅copy 的问题。话虽如此，如果对于前面所说的有个大概了解，相信实现也不是不可能。

在C#中，尤其自己定义类型的时候，常常由于是用 struct来定义还是用class来定义，即是定义一个值类型还是一个引用类型呢。在这本书上给了几个判定条件，如果如下几点都满足的话，建议用 struct来定义为值类型，否则用class定义为引用类型。

<!--[if !supportLists]-->1． <!--[endif]-->这个类型是否主要为了数据存储；
<!--[if !supportLists]-->2． <!--[endif]-->是否只通过属性来访问对象的数据成员；
<!--[if !supportLists]-->3． <!--[endif]-->这个类型是否不会有子类型；
<!--[if !supportLists]-->4． <!--[endif]-->在程序处理的时候不会把这个类型对象通过多态来处理。

（1）The Graphics class provides methods for drawing lines, curves, figures, images, and text. A Graphics object stores attributes of the display device and attributes of the items to be drawn.【msdn】

        Graphics是一个device context和你的drawing conetent之间的一个中介。它存储了device context的相关属性，以及drawing content的属性。这样，它就能用自己的方法把drawing content“映射”到device content 之上。

（2）GDI+的核心是Graphics类，包含了显示、绘图等功能。它提供了四个构造函数：
   Graphics::Graphics(Image*)
   Graphics::Graphics(HDC)
   Graphics::Graphics(HDC,HANDLE)
   Graphics::Graphics(HWND,BOOL)

   构造函数1从image对象创建一个Graphics类。这种方式允许你在打开某张，或者生成某张位图之后，应用Grapgics的方法对改位图进行操作。

   构造函数2从一个传统的HDC获取一个Graphics对象，把传统的在HDC完成的操作接手过来。也就是当要画直线，曲线，图形等时，采用这种构造函数。

   后面两种构造函数这里不说了！

（3）如果读者有GDI编程经验的话，应该会联想起CDC::CreateCompatibleDC和CBitmap::
CreateCompatibleBitmap吧？再列举Graphics中有代表性的用于绘图的成员函数：
   Graphics::DrawArc(Pen*,INT,INT,INT,INT,REAL,REAL)
   Graphics::DrawBeziers(Pen*,Point*,INT)
   Graphics::DrawClosedCurve(Pen*,Point*,INT)
   Graphics::DrawCurve(Pen*,Point*,INT)
   Graphics::DrawEllipse(Pen*,Rect&amp;)
   Graphics::DrawImage(Image*,RectF&amp;)
   Graphics::DrawLine(Pen*,Point&amp;,Point&amp;)
   Graphics::DrawPie(Pen*,Rect&amp;,REAL,REAL)
   Graphics::DrawPolygon(Pen*,Point*,INT*)
   Graphics::DrawRectangle(Pen*,Rect&amp;)
   是不是非常象CDC？从这里大家也能猜出一点Graphics类和CDC类的异同吧！简单的说，Graphics的层次更高一些，封装的更好。

2  GDI+的几个特点：

   （1）传统的GDI编程最痛苦的是什么？是不停的CreateObject，SeleteObject，DeleteObject——代码繁琐，一不小心还会内存泄露……现在GDI+结束了这一切，就凭这一个理由，也足够我们转向GDI+了，呵呵。从上面的几个成员函数可以看出来，每个绘图动作都指定了画笔、刷子或者Image，完全抛弃了SelectObject的概念。

   （2）GDI+里面的颜色更加丰富，全面支持32位色，从Color类的构造函数就可以看出来：

           Color::Color(BYTE a, BYTE r, BYTE g, BYTE b);其中a就是透明度。

   （3）GDI+里的所有函数都只接受Unicode字符串，编写代码的时候需要注意这一点。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/keyouan2008/archive/2010/08/13/5809519.aspx