C++博客-天下-随笔分类-C#

c#条件编译

天下 — Wed, 26 Jun 2019 10:03:00 GMT

Conditional compilation symbols

编译器命令行选项（例如，/define:DEBUG）,

可以在VS2008的IDE进行设置, Project Property--->Build--->Conditional compilation symbols(如果多个科研使用逗号隔开)

系统默认设置了:DEBUG 和 TRACE

操作系统外壳程序中的环境变量（例如，set DEBUG=1）。

源代码中的杂注（例如，用于定义编译变量的 #define DEBUG，以及用于取消定义它的 #undef DEBUG）。

必须在file的最前方设置,#define debug或者组合操作

#if (Debug && Trace)

#define DebugAndTrace

#endif

ps:Conditional位于using System.Diagnostics;

什么情况下使用该标识符?

当程序中一个方法或属性不想再使用时,如果把它删掉就需要把引用的地方一个一个全部删掉不然就会编译错误,这时我们就可以在塔的上面加一个[Conditional("string")] 然后程序运行时就会忽略它

ps:[Conditional("string")]里面字符串随意取

如果想再次调用那个方法或属性怎么办?

这个很简单,你只需在引用命名空间那个地方进行一个宏定义把你在[Conditional("string")]里面的字符串定义出来就能用了

C#-#define条件编译

C#的预处理器指令从来不会转化为可执行代码的命令，但是会影响编译过程的各个方面，常用的预处理器指令有#define、#undef、#if,#elif,#else和#endif等等，下面介绍C#中使用#define进行条件编译的实例。

C#中条件编译指令用于按条件包含或排除源文件中的某些部分。在Visual Studio中，会看到被排除的代码显示为灰色。

一、#define可以用来做什么

1、当计划发布两个版本的代码的时候。即基本版和拥有更多版本的企业版，就可以用到条件编译指令；

2、例如同一个文件给silverlight、wpf、winform等使用，并且还考虑Debug和Release等，有大部分代码是一样的；

3、指定函数和属性是否编译到最终产品中去。

二、#define用法

语法：#define 名称

注意：这里名称取Debug，你也可以取其他名称如Dragon

1 #define Debug

说明：

1、Debug可以看做是声明的一个变量，但此变量没有真正的值，存在时#if Debug结果为true，否则为false；

2、#define单独用没什么意义，一般是和#if或者Conditional特性结合使用；

3、#define必须定义在所有using命名空间前面；

4、Debug与DEBUG是不同的，C#区分大小写

天下 2019-06-26 18:03 发表评论

C# invoke,BeginInvoke,EndInvoke

天下 — Thu, 08 Sep 2016 02:16:00 GMT

C# invoke,BeginInvoke,EndInvoke
在多线程编程中，我们经常要在工作线程中去更新界面显示，而在多线程中直接调用界面控件的方法是错误的做法，Invoke 和 BeginInvoke 就是为了解决这个问题而出现的，使你在多线程中安全的更新界面显示。
正确的做法是将工作线程中涉及更新界面的代码封装为一个方法，通过 Invoke 或者 BeginInvoke 去调用，两者的区别就是一个导致工作线程等待，而另外一个则不会。
再举个简单例子说明下使用方法,比如你在启动一个线程,在线程的方法中想更新窗体中的一个TextBox..

using System.Threading;
//启动一个线程
Thread thread=new Thread(new ThreadStart(DoWork));
thread.Start();
//线程方法
private void DoWork()
{
    this.TextBox1.Text="我是一个文本框";
}
如果你像上面操作,在VS2005或2008里是会有异常的

正确的做法是用Invoke\BeginInvoke
using System.Threading;
namespace test
{
    public partial class Form1 : Form
    {
        public delegate void MyInvoke(string str1,string str2);
        public Form1()
        {
            InitializeComponent();
        }
        public void DoWork()
        {
            MyInvoke mi = new MyInvoke(UpdateForm);
            this.BeginInvoke(mi, new Object[] {"我是文本框","haha"});
        }
        public void UpdateForm(string param1,string parm2)
        {
            this.textBox1.Text = param1+parm2;
        }
        private void button1_Click(object sender, EventArgs e)
        {
            Thread thread = new Thread(new ThreadStart(DoWork));
            thread.Start();
        }
    }
}

相关资料：Invoke 和 BeginInvoke 的真正涵义、在多线程中如何调用Winform
Control.BeginInvoke 方法  Visual Studio 2010Visual Studio 2010
在创建控件的基础句柄所在线程上异步执行委托。
公共方法 BeginInvoke(Delegate) 在创建控件的基础句柄所在线程上异步执行指定委托。
公共方法 BeginInvoke(Delegate,Object[])  在创建控件的基础句柄所在线程上，用指定的参数异步执行指定委托。
public Object EndInvoke(IAsyncResult asyncResult)
参数：asyncResult 类型：System.IAsyncResult
IAsyncResult，表示特定的调用异步操作，在调用 BeginInvoke 时返回。

天下 2016-09-08 10:16 发表评论

String.Format

天下 — Fri, 02 Sep 2016 06:23:00 GMT

每个格式项都采用下面的形式并包含以下组件：

{索引[,对齐][:格式字符串]}

必须使用成对的大括号（“{”和“}”）。

转义大括号

左大括号和右大括号被解释为格式项的开始和结束。因此，必须使用转义序列显示文本左大括号或右大括号。在固定文本中指定两个左大括号 ("{{") 以显示一个左大括号 ("{")，或指定两个右大括号 ("}}") 以显示一个右大括号 ("}")。按照在格式项中遇到大括号的顺序依次解释它们。不支持解释嵌套的大括号。

下表描述了每个标准格式说明符的标准格式模式，以及可通过设置来修改标准格式的关联 NumberFormatInfo 属性。

ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/fxref_mscorlib/html/b42c00a5-84e5-51a1-b7e4-6aaae8dac25b.htm

ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/dv_fxfund/html/580e57eb-ac47-4ffd-bccd-3a1637c2f467.htm

格式模式	说明和关联属性
c、C	货币格式
d、D	十进制格式
e、E	科学计数（指数）格式
f、F	固定点格式
g、G	常规格式
n、N	数字格式
p、P	百分比格式
r、R	往返格式
x、X	十六进制格式

天下 2016-09-02 14:23 发表评论

C#基础知识加强，值类型，应用类型

天下 — Fri, 02 Sep 2016 01:18:00 GMT

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using TK;
namespace ConsoleTester
{
    class Program
    {
        public class SomeRef
        {
            public Int32 x;
        }
        public struct SomeVal
        {
            public Int32 x;
        }
        static void Main(string[] args)
        {
            var r1 = new SomeRef(); //堆上分配
            var v1 = new SomeVal(); //栈上分配，同时确保值类型字段初始化为0.

            r1.x = 5;
            v1.x = 6;

            SomeRef r2 = r1;
            r2.x = 7;
            Console.WriteLine("r1.x={0}", r1.x);
            Console.WriteLine("r2.x={0}", r2.x);

            var v2 = v1;
            v2.x = 8;

            Console.WriteLine("v1.x={0}", v1.x);
            Console.WriteLine("v2.x={0}", v2.x);

            Console.Read();

        }
    }
}

天下 2016-09-02 09:18 发表评论

C++ CLI 可变参数

天下 — Thu, 01 Sep 2016 06:48:00 GMT

namespace TK
{
    public enum class LogLevel { Kernel, Fatal, Error, Warning, Infomation, Debug};
    public ref class LogHelper
    {
    public:
        static bool Open(String^ filename);
        static void Close();
        static bool Write(LogLevel level,String^ format, array^ args);
        static bool WriteLine(LogLevel level,String^ format, array^ args);
        static void SetLevel(LogLevel level);
    };
}

static void MarshalString(String^ net, CString& os) {
    LPCTSTR chars = (LPCTSTR)(Marshal::StringToHGlobalUni(net)).ToPointer();
    os = chars;
    Marshal::FreeHGlobal(IntPtr((void*)chars));
}
#pragma unmanaged
static CStringA CStrW2CStrA(const CStringW &cstrSrcW)
{
    int len = WideCharToMultiByte(CP_UTF8, 0, LPCWSTR(cstrSrcW), -1, NULL, 0, NULL, NULL);
    char *str = new char[len];
    memset(str, 0, len);
    WideCharToMultiByte(CP_UTF8, 0, LPCWSTR(cstrSrcW), -1, str, len, NULL, NULL);
    CStringA cstrDestA = str;
    delete[] str;

    return cstrDestA;
}
#pragma managed

天下 2016-09-01 14:48 发表评论

Dev Express 一些Tips

天下 — Thu, 21 Jul 2016 01:54:00 GMT

Dev Express

Skin Libraries
Skins for DevExpress components are shipped in compiled libraries. To apply a skin, ensure that a corresponding library is added to the References section of your project.

Common Skins
The DevExpress.Utils.v15.2.dll library contains common skins such as the DevExpress Style, Office 2013, VS2010, Office 2010 Blue, etc. This library is automatically added to the References section of your project when any DevExpress control/component is added to the form.

Extra Skins
Certain additional skins are available in the DevExpress.BonusSkins.v15.2.dll library, which must be manually added to the References section if you need to use any of these bonus skins.

Custom Skins
You can customize any common or extra skin by creating a custom skin using the WinForms Skin Editor utility. The WinForms Skin Editor creates a skin library (.dll) containing custom skins. The created library must be manually added to the References section of your project.

Note
To use any extra or custom skin at runtime, you need to add the skin library registration code. See the Bonus and Custom Skin Registration topic to learn more.
[STAThread]
static void Main() {
    // Skin registration.
    DevExpress.UserSkins.BonusSkins.Register();
    Application.Run(new Form1());
}

使动态皮肤即刻生效
It is possible to call the EnableFormSkins() method later, after the application startup. In this instance, the DevExpress.LookAndFeel.LookAndFeelHelper.ForceDefaultLookAndFeelChanged method needs to be called after the call to EnableFormSkins(). This forces the form's title bar to be repainted.
DevExpress.Skins.SkinManager.EnableFormSkins();
DevExpress.LookAndFeel.LookAndFeelHelper.ForceDefaultLookAndFeelChanged();
或者
DevExpress.Skins.SkinManager.DisableFormSkins();
DevExpress.LookAndFeel.LookAndFeelHelper.ForceDefaultLookAndFeelChanged();

动态换皮肤
//添加控件 comboBoxEdit1
public partial class Form1 :  DevExpress.XtraEditors.XtraForm
{
    public Form1()
    {
        InitializeComponent();
        foreach (SkinContainer cnt in SkinManager.Default.Skins)
            comboBoxEdit1.Properties.Items.Add(cnt.SkinName);
        comboBoxEdit1.SelectedIndexChanged += new EventHandler(comboBoxEdit1_SelectedIndexChanged);
    }
    void comboBoxEdit1_SelectedIndexChanged(object sender, EventArgs e)
    {
        ComboBoxEdit comboBox = sender as ComboBoxEdit;
        string skinName = comboBox.Text;
        //DevExpress.LookAndFeel.UserLookAndFeel.Default.SkinName = skinName;
        this.LookAndFeel.SkinName = skinName;
    }
}

//using DevExpress.XtraBars.Helpers;
    public partial class Form1 :  DevExpress.XtraEditors.XtraForm
    {
        public Form1()
        {
            InitializeComponent();
            this.barManager1.ForceInitialize();
            alertControl1.BeforeFormShow += alertControl1_BeforeFormShow;

            //禁止barManage右键显示
            this.barManager1.AllowCustomization = false;
            this.barManager1.AllowShowToolbarsPopup = false;
            //去除barManage右边小三角自定制
            this.barManager1.AllowQuickCustomization = false;

            this.LookAndFeel.UseDefaultLookAndFeel = true;
            //添加一个BarSubItem DevExpress.XtraBars.BarSubItem mPaintStyle;
            //添加换肤
            SkinHelper.InitSkinPopupMenu(mPaintStyle);

            //标题栏支持皮肤
            DevExpress.Skins.SkinManager.EnableFormSkins();
        }
}

天下 2016-07-21 09:54 发表评论

C#关键字implicit 和 explicit

天下 — Fri, 17 Jun 2016 06:06:00 GMT

C#关键字implicit 和 explicit

explicit（C# 参考）
explicit 关键字用于声明必须使用强制转换来调用的用户定义的类型转换运算符。例如，在下面的示例中，此运算符将名为 Fahrenheit 的类转换为名为 Celsius 的类：
// Must be defined inside a class called Fahrenheit:
public static explicit operator Celsius(Fahrenheit fahr)
{
    return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32));
}
可以如下所示调用此转换运算符：
Fahrenheit fahr = new Fahrenheit(100.0f);
Console.Write("{0} Fahrenheit", fahr.Degrees);
Celsius c = (Celsius)fahr;
转换运算符将源类型转换为目标类型。源类型提供转换运算符。与隐式转换不同，必须通过强制转换的方式来调用显式转换运算符。如果转换操作可能导致异常或丢失信息，则应将其标记为 explicit。这可以防止编译器无提示地调用可能产生无法预见后果的转换操作。
省略此强制转换将导致编译时错误 CS0266。

implicit（C# 参考）
implicit 关键字用于声明隐式的用户定义类型转换运算符。如果可以确保转换过程不会造成数据丢失，则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。
隐式转换可以通过消除不必要的类型转换来提高源代码的可读性。但是，因为隐式转换不需要程序员将一种类型显式强制转换为另一种类型，所以使用隐式转换时必须格外小心，以免出现意外结果。一般情况下，隐式转换运算符应当从不引发异常并且从不丢失信息，以便可以在程序员不知晓的情况下安全使用它们。如果转换运算符不能满足那些条件，则应将其标记为 explicit。
class Digit
{
    public Digit(double d) { val = d; }
    public double val;
    // other members

    // User-defined conversion from Digit to double
    public static implicit operator double(Digit d)
    {
        return d.val;
    }
    //  User-defined conversion from double to Digit
    public static implicit operator Digit(double d)
    {
        return new Digit(d);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Digit dig = new Digit(7);
        //This call invokes the implicit "double" operator
        double num = dig;
        //This call invokes the implicit "Digit" operator
        Digit dig2 = 12;
        Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
        Console.ReadLine();
    }
}

天下 2016-06-17 14:06 发表评论

动态调用WebService(C#)

天下 — Fri, 17 Jun 2016 02:53:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->动态调用WebService(C#)转自:http://www.cnblogs.com/xuwb/archive/2012/09/25/2701629.html通常我们在程序中需要调用WebService... 阅读全文

天下 2016-06-17 10:53 发表评论

WebService操作

天下 — Fri, 17 Jun 2016 02:33:00 GMT

WebService操作
转自:
http://blog.csdn.net/hi_kong/article/details/46356801

http://www.cnblogs.com/wayne-ivan/archive/2014/07/14/3842341.html

一、服务器端：
在VS2010中新建项目，首先选择.net framework2.0，然后再选择web服务应用程序。如图所示：
然后在Service.cs文件中添加自己的方法即可。
二、C#winform调用webservice服务

新建C#winfrom工程，右键引用-》添加服务引用-》高级-》添加web引用，在URL后添加需要连接的url（运行上面web服务程序浏览器中就会出现连接的url），然后点击后面的箭头，再点添加引用即可。
假设引用的服务名为WebReference，类名称为Service，
using System.Web.Services;
using System.Web.Services.Description;
在代码中如下操作：

WebReference.Service1 helloWord = new WebReference.Service1();
helloWord .Url =WebUrl;//设置url
helloWord.helloWord（）;//调用webservice中的方法
结束。

WebService处理大数据量数据
在通过WebService处理大数据量数据时出现如下错误：
soap fault: 运行配置文件中指定的扩展时出现异常。 ---> 超过了最大请求长度。
解决方法：
因为上传的文件大于系统默认配置的值，asp.net web service默认的请求长度是4M。
1、针对单个项目，只需修改Web.config就可以了：
修改配置可以在web.config中重新设置，如下：

<configuration>
<system.web>
<httpRuntime maxRequestLength="1048576" executionTimeout="3600" />
system.web>
configuration>

天下 2016-06-17 10:33 发表评论

精简版本WCF DEMO

天下 — Thu, 16 Jun 2016 01:46:00 GMT

using System;
using System.ServiceModel; //添加System.ServiceModel引用
using System.ServiceModel.Channels;

namespace ConsoleApplication1
{
    [ServiceContract]
    public interface IHelloWCF
    {
        [OperationContract]
        void Say(string input);
    }
    public sealed class HelloService : IHelloWCF
    {
        public void Say(string input)
        {
            Console.WriteLine("Hello {0}", input);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Uri address = new Uri("http://127.0.0.1:8733/IHelloWCF");
            BasicHttpBinding binding = new BasicHttpBinding();
            ServiceHost svc = new ServiceHost(typeof(HelloService));
            svc.AddServiceEndpoint(typeof(IHelloWCF), binding, address);
            svc.Opened += delegate {
                Console.WriteLine("The HelloWCF receiving application is ready");
            };
            svc.Open();

            ChannelFactory<IHelloWCF> factory = new ChannelFactory<IHelloWCF>(binding,new EndpointAddress(address));
            IHelloWCF proxy = factory.CreateChannel();
            proxy.Say("张三");
            proxy.Say("李四");
            proxy.Say("王二麻子");

            Console.ReadLine();
            svc.Close();
        }
    }
}

天下 2016-06-16 09:46 发表评论

WCF元数据公布的2种方式：httpGetEnabled与mex

天下 — Wed, 15 Jun 2016 07:42:00 GMT

WCF元数据公布的2种方式：httpGetEnabled与mex
一、元数据即WSDL，描述了服务的细节，以便客户端使用。
二、必须为服务配置ServiceMetadata行为，才能为其生成WSDL，才能再使用httpGetEnabled或mex将其公布出去
三、这两种方式公布出去的WSDL无区别。但公布的方式有区别
1、httpGetEnabled=true，类似的还有httpsGetEnabled=true
此方式通过在服务在的URL后加“?wsdl”的方式公布WSDL，可直接通过HTTP访问得到。

2、mex
此方式以一般的终结点方式公布，支持各种协议：http、tcp、NamedPipe

天下 2016-06-15 15:42 发表评论

WCF 数据契约（DataContract）

天下 — Mon, 13 Jun 2016 09:52:00 GMT

数据契约（DataContract）
服务契约定义了远程访问对象和可供调用的方法，数据契约则是服务端和客户端之间要传送的自定义数据类型。
一旦声明一个类型为DataContract，那么该类型就可以被序列化在服务端和客户端之间传送，如下所示。
     [DataContract]
     public class UserInfo
     {
          //….
     }
只有声明为DataContract的类型的对象可以被传送，且只有成员属性会被传递，成员方法不会被传递。WCF对声明为DataContract的类型提供更加细节的控制，可以把一个成员排除在序列化范围以外，也就是说，客户端程序不会获得被排除在外的成员的任何信息，包括定义和数据。默认情况下，所有的成员属性都被排除在外，因此需要把每一个要传送的成员声明为DataMember，如下所示。
    [DataContract]
    public class UserInfo
    {
        [DataMember]
        public string UserName
        {
            get;
            set;
        }
        [DataMember]
        public int Age
        {
            get;
            set;
        }
        [DataMember]
        public string Location
        {
            get;
            set;
        }
        public string Zodiac
        {
            get;
            set;
        }
}
上面这段代码把UserInfo类声明为DataContract，将UserName、Age、Location这3个属性声明为DataMember（数据成员）。Zodiac成员没有被声明为DataMember，因此在交换数据时，不会传输Zodiac的任何信息。
DataContract也支持Name/Namespace属性，如同ServiceContract，Name和Namespace可以自定义名称和命名空间，客户端将使用自定义的名称和命名空间对DataContract类型进行访问。
声明为DataMember的成员也可以自定义客户端可见的名称，例如：
[DataMember(Name="Name")]
public string UserName
{
     get;
     set;
}
[DataMember(Name="Age")]
public int UserAge
{
          get;
          set;
}
除了Name和Namespace以外，DataMember还有以下参数，它们的含义分别如下。
（1）IsRequired：值为true时，要求序列化引擎检查对象是否存在该值；若无，则会有异常抛出。
（2）Order：bool类型值，值为true时，序列化和反序列化过程将会按成员定义的顺序进行，这对依赖于成员位置的反序列化过程无比重要。
（3）EmitDefaultvalue：为成员属性设置一个默认值。

天下 2016-06-13 17:52 发表评论

char和wchar_t 转String^

天下 — Mon, 21 Dec 2015 11:07:00 GMT

#include "stdafx.h"
#include
#using
using namespace System;
using namespace System::Text;
using namespace System::Runtime::InteropServices;

#ifdef _MANAGED
#endif

void abc123()
{
    using namespace msclr::interop;
    const char* msg1 = "Test String to Marshal";
    const wchar_t* msg2= L"Good Luck Aaron";
    String^ aMsg = marshal_as(msg1);
    String^ uMsg = marshal_as(msg2);
    Console::WriteLine(aMsg);
    Console::WriteLine(uMsg);
}
#pragma unmanaged
int _tmain(int argc, _TCHAR* argv[])
{
    abc123();
    system("pause");
    return 0;
}
#pragma managed

天下 2015-12-21 19:07 发表评论

略谈GCHandle【转】

天下 — Mon, 21 Dec 2015 10:36:00 GMT

略谈GCHandle【转】
http://blog.163.com/vk_01313/blog/static/17219228200912491729457/
我们在使用c#托管代码时，内存地址和GC回收那不是我们关心的，CLR已经给我们暗箱操作。
但是如果我们在c#中调用了一个非托管代码，比如vc的DLL,而且他有个回调函数，需要引用c#中的某个对象并操作，
这时候你就得要小心了。
要是非托管代码中用到得托管代码那个对象被GC给回收了，这时候就会报内存错误。
所以我们就要把那个对象“钉”住(pin)，让它的内存地址固定，而不被垃圾回收掉，然后最后我们自己管理，自己释放内存,这时候就需要GCHandle,来看个msdn上的例子:

using System.Runtime.InteropServices;

namespace ConsoleApplication1
{

    //C#
    public delegate bool CallBack(int handle, IntPtr param);
    public class LibWrap
    {
        [DllImport("user32.dll")]
        public static extern bool EnumWindows(CallBack cb, IntPtr param);
    }

    class Program
    {
        static void Main(string[] args)
        {
            TextWriter tw = System.Console.Out;
            GCHandle gch = GCHandle.Alloc(tw);
            CallBack cewp = new CallBack(CaptureEnumWindowsProc);
            LibWrap.EnumWindows(cewp, (IntPtr)gch);
            gch.Free();
            Console.Read();

        }
        private static bool CaptureEnumWindowsProc(int handle, IntPtr param)
        {
            GCHandle gch = (GCHandle)param;
            TextWriter tw = (TextWriter)gch.Target;
            tw.WriteLine(handle);
            return true;
        }

    }
}

对上面的代码，略加解释：gch 会钉住(pin)tw这个对象，使其不受GC管理，告诉它，以后你崩管我，我也不用给你上税,其实管理权已经给gch，通过free来释放内存。
这种情况主要用在托管和非托管代码交互的时候，防止内存泄露来使用GCHandle。

天下 2015-12-21 18:36 发表评论

pin_ptr 和 interior_ptr

天下 — Mon, 21 Dec 2015 09:11:00 GMT

CLR语法中，值类型指针分为两种类型：V*（限于非 CLR 堆位置）和内部指针 interior_ptr（允许但不要求托管堆内的地址）。

钉住指针
通常，在压缩阶段，垃圾回收器可选择将驻留在 CLR 堆上的对象移动到堆内的不同位置。这种移动对于跟踪句柄、跟踪引用和内部指针而言不是问题，它们都透明地更新这些实体。但是，如果用户在运行时环境外传递了 CLR 堆上对象的地址，这种移动就会导致问题。在这种情况下，对象的不稳定运动可能导致运行时失败。要避免此类对象的移动，必须在本地将它们钉在自己的位置上以供外部使用。

在托管扩展中，“钉住指针”是通过使用 __pin 关键字限定指针声明来声明的。下面是一个来自托管扩展规范的经过略微修改的示例：

  复制代码
__gc struct H { int j; };

int main()
{
   H * h = new H;
   int __pin * k = & h -> j;

   // …
};

在新的语言设计中，钉住指针是使用类似于内部指针的语法来声明的。

  复制代码
ref struct H
{
public:
   int j;
};

int main()
{
   H^ h = gcnew H;
   pin_ptr<int> k = &h->j;

   // …
}

interior_ptr
Declares a pointer to inside a reference type, but not to the object itself. An interior pointer can point to a reference handle, value type, boxed type handle, member of a managed type, or to an element of a managed array.
cli::interior_ptr var = &initializer;

Remarks
A native pointer is not able to track an item as its location changes on the managed heap, which results from the garbage collector moving instances of an object. In order for a pointer to correctly refer to the instance, the runtime needs to update the pointer to the newly positioned object.

An interior_ptr represents a superset of the functionality of a native pointer. Therefore, anything that can be assigned to a native pointer can also be assigned to an interior_ptr. An interior pointer is permitted to perform the same set of operations as native pointers, including comparison and pointer arithmetic.

An interior pointer can only be declared on the stack. An interior pointer cannot be declared as a member of a class.

Since interior pointers exist only on the stack, taking the address of an interior pointer yields an unmanaged pointer.

interior_ptr has an implicit conversion to bool, which allows for its use in conditional statements.

For information on how to declare an interior pointer that points into an object that cannot be moved on the garbage-collected heap, see pin_ptr.

interior_ptr is in the cli namespace. See cli Namespace for more information.

//Example
// interior_ptr.cpp
// compile with: /clr
using namespace System;

ref class MyClass {
public:
   int data;
};

int main() {
   MyClass ^ h_MyClass = gcnew MyClass;
   h_MyClass->data = 1;
   Console::WriteLine(h_MyClass->data);

   interior_ptr<int> p = &(h_MyClass->data);
   *p = 2;
   Console::WriteLine(h_MyClass->data);

   // alternatively
   interior_ptr p2 = &h_MyClass;
   (*p2)->data = 3;
   Console::WriteLine((*p2)->data);
}

天下 2015-12-21 17:11 发表评论

StructLayout特性

天下 — Mon, 21 Dec 2015 08:27:00 GMT

StructLayout特性

     公共语言运行库利用StructLayoutAttribute控制类或结构的数据字段在托管内存中的物理布局,即类或结构需要按某种方式排列。如果要将类传递给需要指定布局的非托管代码，则显式控制类布局是重要的。它的构造函数中用 LayoutKind值初始化 StructLayoutAttribute 类的新实例。 LayoutKind.Sequential 用于强制将成员按其出现的顺序进行顺序布局。

  StructLayout特性允许我们控制Structure语句块的元素在内存中的排列方式,以及当这些元素被传递给外部DLL时，运行库排列这些元素的方式。Visual   Basic结构的成员在内存中的顺序是按照它们出现在源代码中的顺序排列的，尽管编译器可以自由的插入填充字节来安排这些成员，以便使得16位数值用子边界对齐，32位数值用双字边界对齐。

  使用这种排列（未压缩布局）提供的性能最佳。

通过System.Runtime.InteropServices.StructLayout   特性精确的控制每一个结构成员的位置。
System.Runtime.InteropServices.StructLayout   允许的值有:
StructLayout.Auto
StructLayout.Sequential
StructLayout.Explicit

1.Sequential,顺序布局,比如
struct S1
{
  int a;
  int b;
}
那么默认情况下在内存里是先排a,再排b
也就是如果能取到a的地址,和b的地址,则相差一个int类型的长度,4字节
[StructLayout(LayoutKind.Sequential)]
struct S1
{
  int a;
  int b;
}
这样和上一个是一样的.因为默认的内存排列就是Sequential,也就是按成员的先后顺序排列.
2.Explicit,精确布局
需要用FieldOffset()设置每个成员的位置
这样就可以实现类似c的公用体(union)的功能
[StructLayout(LayoutKind.Explicit)]
struct S1
{
    [FieldOffset(0)] int a;
    [FieldOffset(0)] int b;
}
这样a和b在内存中地址相同

  StructLayout特性支持三种附加字段：CharSet、Pack、Size。
·   CharSet定义在结构中的字符串成员在结构被传给DLL时的排列方式。可以是Unicode、Ansi或Auto。
  默认为Auto，在WIN   NT/2000/XP中表示字符串按照Unicode字符串进行排列，在WIN   95/98/Me中则表示按照ANSI字符串进行排列。
·   Pack定义了结构的封装大小。可以是1、2、4、8、16、32、64、128或特殊值0。特殊值0表示当前操作平台默认的压缩大小。

  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
    public struct LIST_OPEN
    {
        public int dwServerId;
        public int dwListId;
        public System.UInt16 wRecordSize;
        public System.UInt16 wDummy;
        public int dwFileSize;
        public int dwTotalRecs;
        public NS_PREFETCHLIST sPrefetch;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 24)] public string szSrcMach;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 24)] public string szSrcComp;
    }

此例中用到MashalAs特性，它用于描述字段、方法或参数的封送处理格式。用它作为参数前缀并指定目标需要的数据类型。
例如，以下代码将两个参数作为数据类型长指针封送给 Windows API 函数的字符串 (LPStr)：
[MarshalAs(UnmanagedType.LPStr)] String existingfile;

[MarshalAs(UnmanagedType.LPStr)] String newfile;

注意结构作为参数时候，一般前面要加上ref修饰符，否则会出现错误：对象的引用没有指定对象的实例。
[ DllImport( "kernel32", EntryPoint="GetVersionEx" )]
public static extern bool GetVersionEx2( ref OSVersionInfo2 osvi );

string result;
IntPtr strPtr = new IntPtr() ;// unmanaged api TestStringAsResultIntPrt(1);
result = Marshal.PtrToStringUni(strPtr);
result = Marshal.PtrToStringAnsi(strPtr);
Marshal.FreeCoTaskMem(strPtr);

天下 2015-12-21 16:27 发表评论

如何：将 System::String 转换为标准字符串

天下 — Mon, 14 Dec 2015 07:46:00 GMT

//《精通.NET互操作：P/Invoke、C++ Interop和COM Interop》
//ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/dv_vccore/html/79e2537e-d4eb-459f-9506-0e738045b59e.htm
// convert_system_string.cpp
// compile with: /clr
#include <string>
#include
using namespace std;
using namespace System;

void MarshalString ( String ^ s, string& os ) {
   using namespace Runtime::InteropServices;
   const char* chars =
      (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

void MarshalString ( String ^ s, wstring& os ) {
   using namespace Runtime::InteropServices;
   const wchar_t* chars =
      (const wchar_t*)(Marshal::StringToHGlobalUni(s)).ToPointer();
   os = chars;
   Marshal::FreeHGlobal(IntPtr((void*)chars));
}

int main() {
   string a = "test";
   wstring b = L"test2";
   String ^ c = gcnew String("abcd");

   cout << a << endl;
   MarshalString(c, a);
   c = "efgh";
   MarshalString(c, b);
   cout << a << endl;
   wcout << b << endl;
}

天下 2015-12-14 15:46 发表评论

C++的dll调用C#的dll

天下 — Mon, 07 Dec 2015 12:23:00 GMT

C++的dll调用C#的dll
1）用C#写任何的类库，如：NeoWayMesCommon.dll
2）C++的dll中要引用此类库，注意不能在stdafx.h中引用，最后是在cpp文件中引用。
#using
#using "../Debug/NeoWayMesCommon.dll" //引用此类库
using namespace NeoWayMes;
using namespace System;
3) C++ 编译设置一定设置为：支持公共语言运行时支持(/clr)
4) 必须将C#的dll拷贝至VC工程运行的目录，否则报异常错误。
5) 其他的参见c++/cli语法标准

天下 2015-12-07 20:23 发表评论

Double Thunking

天下 — Tue, 01 Dec 2015 03:14:00 GMT

By default, when compiling with /clr (not /clr:pure), the definition of a managed function causes the compiler to generate a managed entry point and a native

entry point. This allows the managed function to be called from native and managed call sites. However, when a native entry point exists, it can be the entry

point for all calls to the function. If a calling function is managed, the native entry point will then call the managed entry point. In effect, two calls

are required to invoke the function (hence, double thunking). For example, virtual functions are always called through a native entry point.

One resolution is to tell the compiler not to generate a native entry point for a managed function, that the function will only be called from a managed

context, by using the __clrcall calling convention.

Similarly, if you export (dllexport, dllimport) a managed function, a native entry point is generated and any function that imports and calls that function

will call through the native entry point. To avoid double thunking in this situation, do not use native export/import semantics; simply reference the

metadata via #using (see The #using Directive).

In Visual C++ 2005 the compiler was updated to reduce unnecessary double thunking. For example, any function with a managed type in the signature (including

return type) will implicitly be marked as __clrcall. For more information on double thunk elimination, see

http://msdn.microsoft.com/msdnmag/issues/05/01/COptimizations/default.aspx.

Example

The following sample demonstrates double thunking. When compiled native (without /clr), the call to the virtual function in main generates one call to T's

copy constructor and one call to the destructor. Similar behavior is achieved when the virtual function is declared with /clr and __clrcall. However, when

just compiled with /clr, the function call generates a call to the copy constructor but there is another call to the copy constructor due to the

native-to-managed thunk.

纯 MSIL 程序集可以调用非托管函数，但不能由非托管函数调用。因此，与非托管函数使用的服务器代码相比，纯 MSIL 更适合于使用非托管函数的客户端代码。

当我们使用/clr选项（不是/clr:pure）进行编译的时候，一个托管函数(managed function)，会导致编译器生成一个托管的入口点(managed entry point)和一个原生的入口点

(native entry point)，这样可以使得托管函数既可以被托管代码调用，也可以被原生代码调用。但是，当一个原生的入口点存在的时候，它将成为所有调用的入口点。也就是说

如果调用者是托管的，它还是会先去调用原生入口点，然后原生的入口点再去调用托管的入口点，这就意味着调用了两次函数入口点（Double Thunking）。

c++ cli 标准

天下 2015-12-01 11:14 发表评论

如何：使用 C++ Interop 封送 ANSI 字符串

天下 — Tue, 01 Dec 2015 03:09:00 GMT

// MarshalANSI1.cpp
// compile with: /clr
#include
#include

using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;

#pragma unmanaged

void NativeTakesAString(const char* p) {
   printf_s("(native) received '%s'\n", p);
}

#pragma managed

int main() {
   String^ s = gcnew String("sample string");
   IntPtr ip = Marshal::StringToHGlobalAnsi(s);
   const char* str = static_cast<const char*>(ip.ToPointer());

   Console::WriteLine("(managed) passing string");
   NativeTakesAString( str );

   Marshal::FreeHGlobal( ip );
}

下面的示例演示访问由非托管函数调用的托管函数中的 ANSI 字符串所需的数据封送处理。托管函数在接收到本机字符串时，可以直接使用该字符串，也可以按所示方式使用 PtrToStringAnsi 方法将其转换为托管字符串。

  复制代码
// MarshalANSI2.cpp
// compile with: /clr
#include
#include

using namespace std;

using namespace System;
using namespace System::Runtime::InteropServices;

#pragma managed

void ManagedStringFunc(char* s) {
   String^ ms = Marshal::PtrToStringAnsi(static_cast(s));
   Console::WriteLine("(managed): received '{0}'", ms);
}

#pragma unmanaged

void NativeProvidesAString() {
   cout << "(native) calling managed func\n";
   ManagedStringFunc("test string");
}

#pragma managed

int main() {
   NativeProvidesAString();
}

天下 2015-12-01 11:09 发表评论

如何：将 System::String 转换为 wchar_t* 或 char*

天下 — Tue, 01 Dec 2015 03:08:00 GMT

ms-help://MS.VSCC.v90/MS.MSDNQTR.v90.chs/dv_vccore/html/385da01b-5649-4543-8076-e3e251243ff0.htm

// convert_string_to_wchar.cpp
// compile with: /clr
#include < stdio.h >
#include < stdlib.h >
#include < vcclr.h >

using namespace System;

int main() {
   String ^str = "Hello";

   // Pin memory so GC can't move it while native function is called
   pin_ptr<const wchar_t> wch = PtrToStringChars(str);
   printf_s("%S\n", wch);

   // Conversion to char* :
   // Can just convert wchar_t* to char* using one of the
   // conversion functions such as:
   // WideCharToMultiByte()
   // wcstombs_s()
   //  etc
   size_t convertedChars = 0;
   size_t  sizeInBytes = ((str->Length + 1) * 2);
   errno_t err = 0;
   char    *ch = (char *)malloc(sizeInBytes);

   err = wcstombs_s(&convertedChars,
                    ch, sizeInBytes,
                    wch, sizeInBytes);
   if (err != 0)
      printf_s("wcstombs_s  failed!\n");

    printf_s("%s\n", ch);
}

天下 2015-12-01 11:08 发表评论

C# using 三种使用方式

天下 — Tue, 10 Nov 2015 02:45:00 GMT

C# using 三种使用方式
1.using指令。using + 命名空间名字，这样可以在程序中直接用命令空间中的类型，而不必指定类型的详细命名空间，类似于Java的import，这个功能也是最常用的，几乎每个cs的程序都会用到。
例如：using System; 一般都会出现在*.cs中。

2.using别名。using + 别名 = 包括详细命名空间信息的具体的类型。
这种做法有个好处就是当同一个cs引用了两个不同的命名空间，但两个命名空间都包括了一个相同名字的类型的时候。当需要用到这个类型的时候，就每个地方都要用详细命名空间的办法来区分这些相同名字的类型。而用别名的方法会更简洁，用到哪个类就给哪个类做别名声明就可以了。注意：并不是说两个名字重复，给其中一个用了别名，另外一个就不需要用别名了，如果两个都要使用，则两个都需要用using来定义别名的。
using Row = Newtonsoft.Json.Linq.JObject;
using Rows = Newtonsoft.Json.Linq.JArray;

3.using语句，定义一个范围，在范围结束时处理对象。
场景：
当在某个代码段中使用了类的实例，而希望无论因为什么原因，只要离开了这个代码段就自动调用这个类实例的Dispose。
要达到这样的目的，用trycatch来捕捉异常也是可以的，但用using也很方便。

using (Class1 cls1 = new Class1(), cls2 = new Class1())
{
// the code using cls1, cls2
} // call

天下 2015-11-10 10:45 发表评论

MySQL简单封装

天下 — Thu, 30 Jul 2015 11:59:00 GMT

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using MySql.Data.MySqlClient;
using System.Xml;
using Row = System.Collections.Generic.Dictionary<string, string>;

namespace NeowayFixPlatform
{

    class MysqlFunction
    {
        public static string table_fix = "nw_fix_record";

        public bool IsConnected()
        {
            return (mysql.State == ConnectionState.Open);
        }
        public MysqlFunction()
        {
            if (mysql.State != ConnectionState.Open)
                mysql.Open();
        }

        ~MysqlFunction()
        {
            if (mysql.State == ConnectionState.Open)
                mysql.Dispose();
        }
        private static String mysqlcon = GetConfigString();
        MySqlConnection mysql = new MySqlConnection(mysqlcon);

        public string quote(ref string value)
        {
            value = value.Replace(@"\", @"\\").Replace("'", @"\'");
            return value;
        }
        public StringBuilder quote(ref StringBuilder value)
        {
            value = value.Replace(@"\", @"\\").Replace("'", @"\'");
            return value;
        }

        public StringBuilder GetPairSQLString(Row row)
        {
            StringBuilder strSQL = new StringBuilder();

            foreach (KeyValuePair<string, string> pair in row)
            {
                string value = pair.Value.ToString();
                this.quote(ref value);
                strSQL.AppendFormat("{0}='{1}',", pair.Key, value);
            }
            strSQL.Remove(strSQL.Length-1, 1);
            return strSQL;
        }

        public bool UpdateOne(string table,Row row,string format,params object[] args)
        {
            StringBuilder condition = new StringBuilder();
            condition.AppendFormat(format, args);
            return this.UpdateOne(table, row, condition.ToString());
        }

        public bool UpdateOne(string strTable, Row row, string strQuery)
        {
            StringBuilder strSQL = new StringBuilder();
            try
            {
                strSQL.AppendFormat("UPDATE {0} set {1} WHERE {2} LIMIT 1", strTable, GetPairSQLString(row), strQuery);
                //mysql.Open();
                MySqlCommand cmd = new MySqlCommand(strSQL.ToString(), mysql);
                cmd.ExecuteNonQuery();
                cmd.Dispose();
                return true;
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            return false;
        }


        public Row FetchOne(string strSQL)
        {
            Row row = new Row();
            try
            {

                //mysql.Open();
                MySqlCommand cmd = new MySqlCommand(strSQL.ToString(),mysql);
                MySqlDataReader reader = cmd.ExecuteReader();
                reader.Read();
                for (int i = 0; i < reader.FieldCount; i++)
                {
                    if (reader.HasRows)
                        row[reader.GetName(i)] = reader[i].ToString();
                }
                reader.Close();
                cmd.Dispose();
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            return row;
        }

        #region 获取登陆字符
        ///

/// 获取登陆字符
///

        ///
        public static string GetConfigString()
        {
            string spath = Application.StartupPath;
            spath += "\\config.xml";
            XmlDocument xml = new XmlDocument();
            xml.Load(spath);
            XmlNode config = xml.SelectSingleNode("config");
            XmlNode dbname = config.SelectSingleNode("dbname");
            XmlNode ipaddr = config.SelectSingleNode("ipaddr");
            XmlNode username = config.SelectSingleNode("username");
            XmlNode password = config.SelectSingleNode("password");

            return string.Format("database={0};Password={1};User ID={2};server={3}", dbname.InnerText, password.InnerText, username.InnerText, ipaddr.InnerText);

        }
        #endregion

        public bool BindData(string sql,ref DataGridView dgv)
        {
            DataSet dataset = new DataSet();
            DataTable datatable = new DataTable();
            try
            {
                MySqlDataAdapter mdap = new MySqlDataAdapter(sql, mysql);
                mdap.Fill(dataset);
                datatable = dataset.Tables[0];
                dgv.DataSource = datatable;
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            return false;
        }

        #region 用户登录
        ///

/// 系统登录
///

        ///
        public bool Login(cUserInfo userinfo)
        {
            DataSet dataset = new DataSet();
            DataTable datatable = new DataTable();
            try
            {
                //MySqlDataAdapter 数据库执行函数，查询，插入，删除都可使用
               MySqlDataAdapter mdap = new MySqlDataAdapter("select * from nw_user where user_name = '" + userinfo.User_name + "' and user_pwd = '" + userinfo.User_password + "'", mysql);
               mdap.Fill(dataset);
               datatable = dataset.Tables[0];

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

            if (datatable.Rows.Count == 1)
            {
                DataRow datarow = datatable.Rows[0];
                userinfo.User_power = datarow["user_power"].ToString();
                return true;
            }
            return false;

        }
        #endregion

        public bool SaveFix(Dictionary<string,string> row,bool bNew)
        {
            StringBuilder strSQL = new StringBuilder();
            try
            {
                if (bNew)
                    strSQL.Append("INSERT INTO nw_fix_record set ");
                else
                    strSQL.Append("UPDATE nw_fix_record set ");
                strSQL.AppendFormat("{0}",GetPairSQLString(row));

                if (!bNew)
                {
                    strSQL.AppendFormat(" WHERE IMEI_MEID='{0}' limit 1", row["IMEI_MEID"]);
                }
                //mysql.Open();

                MySqlCommand cmd = new MySqlCommand(strSQL.ToString(), mysql);
                cmd.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
            return true;
        }

        #region 获取所有产品型号
        ///

/// 获取所有产品型号
///

        ///
        public string[] GetProducts()
        {
            DataSet dataset = new DataSet();
            DataTable datatable = new DataTable();
            string[] rows = null;
            try
            {

                MySqlDataAdapter mdap = new MySqlDataAdapter("select * from nw_product where 1", mysql);
                mdap.Fill(dataset);
                datatable = dataset.Tables[0];

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return rows;
            }

            int row_count = datatable.Rows.Count;
            if (row_count>0)
            {
                rows = new string[row_count];
                for (int i = 0; i < row_count; i++ )
                {
                    rows[i] = datatable.Rows[i][0].ToString();
                }
            }
            return rows;
        }
        #endregion

        #region 获取所有客户名称
        ///

/// 获取所有客户名称
///

        ///
        public string[] GetAllClientName()
        {
            DataSet dataset = new DataSet();
            DataTable datatable = new DataTable();
            string[] rows = null;
            try
            {

                MySqlDataAdapter mdap = new MySqlDataAdapter("select client_name from nw_client where 1", mysql);
                mdap.Fill(dataset);
                datatable = dataset.Tables[0];

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return rows;
            }

            int row_count = datatable.Rows.Count;
            if (row_count > 0)
            {
                rows = new string[row_count];
                for (int i = 0; i < row_count; i++)
                {
                    rows[i] = datatable.Rows[i][0].ToString();
                }
            }
            return rows;
        }
        #endregion

        #region 获取所有维修人员
        ///

/// 获取所有维修人员
///

        ///
        public string[] GetAllRepairEr()
        {
            DataSet dataset = new DataSet();
            DataTable datatable = new DataTable();
            string[] rows = null;
            try
            {

                MySqlDataAdapter mdap = new MySqlDataAdapter("select user_name from nw_user where user_power='维修员' order by user_id", mysql);
                mdap.Fill(dataset);
                datatable = dataset.Tables[0];

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return rows;
            }

            int row_count = datatable.Rows.Count;
            if (row_count > 0)
            {
                rows = new string[row_count];
                for (int i = 0; i < row_count; i++)
                {
                    rows[i] = datatable.Rows[i][0].ToString();
                }
            }
            return rows;
        }

    }
    #endregion

    #region 定义用户表
    public class cUserInfo
        {
            private int user_id;

            public int User_id
            {
                get { return user_id; }
                set { user_id = value; }
            }

            private string user_name;

            public string User_name
            {
                get { return user_name; }
                set { user_name = value; }
            }
            private string user_password;

            public string User_password
            {
                get { return user_password; }
                set { user_password = value; }
            }
            private string user_power;

            public string User_power
            {
                get { return user_power; }
                set { user_power = value; }
            }
        }
   #endregion

}

天下 2015-07-30 19:59 发表评论

杂记Json,MySQL,C#

天下 — Mon, 06 Jul 2015 11:37:00 GMT

MySQL 1045权限错误的解决:
GRANT ALL PRIVILEGES ON *.* TO test_user@'%' IDENTIFIED BY '123456' WITH GRANT OPTION;

libJson(Jsoncpp),够用了.
C++:
extern "C" LIB_MESCLIENT_API int nw_save_prodmade_data(const char* jo_in);

Json::Value jo;
jo["row"]["product_id"] = "21265";
jo["row"]["product_sn"] = 223456789012345678;
int error_code = nw_save_prodmade_data(jo.toStyledString().c_str());

C#下用Newtonsoft.Json也挺好用的
using Newtonsoft.Json.Linq;
JObject jo = new JObject();
jo["row"] = new JObject();
//此部分在dll内部会插入到可追溯状态表 nw_sn_status
jo["row"]["product_id"] = "12\r\n3\"12'\"65"; //产品ID
StringBuilder row = new StringBuilder(jo.ToString());
int error_code = nw_save_prodmade_data(row);

天下 2015-07-06 19:37 发表评论

C#中结构体与字节流互相转换

天下 — Thu, 20 Sep 2012 03:37:00 GMT

一、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的发送和接收。

转自:http://blog.csdn.net/huxiangyang4/article/details/5853247

天下 2012-09-20 11:37 发表评论

C#委派Delegate

天下 — Thu, 07 Jun 2012 08:41:00 GMT

//直接上MSDN上的C#代码:
using System;
public class SamplesDelegate
{

    // Declares a delegate for a method that takes in an int and returns a String.
    public delegate String myMethodDelegate(int myInt);

    // Defines some methods to which the delegate can point.
    public class mySampleClass
    {

        // Defines an instance method.
        public String myStringMethod(int myInt)
        {
            if (myInt > 0)
                return ("positive");
            if (myInt < 0)
                return ("negative");
            return ("zero");
        }

        // Defines a static method.
        public static String mySignMethod(int myInt)
        {
            if (myInt > 0)
                return ("+");
            if (myInt < 0)
                return ("-");
            return ("");
        }
    }

    public static void Main()
    {

        // Creates one delegate for each method. For the instance method, an
        // instance (mySC) must be supplied. For the static method, use the
        // class name.
        mySampleClass mySC = new mySampleClass();
        myMethodDelegate myD1 = new myMethodDelegate(mySC.myStringMethod);
        myMethodDelegate myD2 = new myMethodDelegate(mySampleClass.mySignMethod);

        // Invokes the delegates.
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".", 5, myD1(5), myD2(5));
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".", -3, myD1(-3), myD2(-3));
        Console.WriteLine("{0} is {1}; use the sign \"{2}\".", 0, myD1(0), myD2(0));
    }

}

// d11.cpp : Defines the entry point for the console application.
//C++代码

#include "stdafx.h"
#include <iostream>
#include <string>

using namespace std;

typedef string myMethodDelegate(int myInt);

string myStringMethod ( int myInt )  {
    if ( myInt > 0 )
        return string( "positive" );
    if ( myInt < 0 )
        return string( "negative" );
    return string( "zero" );
}

string mySignMethod ( int myInt )  {
    if ( myInt > 0 )
        return string( "+" );
    if ( myInt < 0 )
        return string( "-" );
    return  string( "" );
}

int _tmain(int argc, _TCHAR* argv[])
{
    myMethodDelegate* myD1 = myStringMethod;
    myMethodDelegate* myD2 = mySignMethod;

    // Invokes the delegates.
    printf( "{%d} is {%s}; use the sign \"{%s}\". \r\n", 5, myD1( 5 ).c_str(), myD2( 5 ).c_str() );
    printf( "{%d} is {%s}; use the sign \"{%s}\". \r\n", -3, myD1( -3 ).c_str(), myD2( -3 ).c_str() );
    printf( "{%d} is {%s}; use the sign \"{%s}\".\r\n", 0, myD1( 0 ).c_str(), myD2( 0 ).c_str() );
    return 0;
}

天下 2012-06-07 16:41 发表评论