首页 / C# / 从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？

从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含12268字，纯文字阅读大概需要18分钟。

内容图文

我想知道,当您在以下我的特殊情况下,通过P / Invoke将回调委托编组到DLL时,是否有可能成为本地世界中托管线程管理问题的受害者？

This MSDN article on Managed and Unmanaged Threading in Windows状态：

“操作系统ThreadId与托管线程没有固定的关系,因为非托管主机可以控制托管线程和非托管线程之间的关系.特别是,复杂的主机可以使用Fiber API针对同一操作系统线程调度许多托管线程. ,或在不同的操作系统线程之间移动托管线程.”

首先,本文介绍谁是非托管主机？如果您像下面的示例代码中那样使用封送处理,那么那里的非托管主机是谁或什么？

同样,this StackOverflow question的可接受答案指出：

“从CLR的角度来看,一个托管线程在其生命周期中由多个不同的本机线程支持是完全合法的.这意味着GetCurrentThreadId的结果可以(并且将)在整个线程生命周期中发生变化.”

那么,这是否意味着我的APC将在本机线程中排队,或者由于封送处理层而直接委派给我的托管线程？

这是例子.假设我使用以下类在托管代码中P /调用NotifyServiceStatusChange函数来检查服务何时停止：

using System;
using System.Runtime.InteropServices;

namespace ServiceStatusChecking
{
    class QueryServiceStatus
    {

        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
        public class SERVICE_NOTIFY
        {
            public uint dwVersion;
            public IntPtr pfnNotifyCallback;
            public IntPtr pContext;
            public uint dwNotificationStatus;
            public SERVICE_STATUS_PROCESS ServiceStatus;
            public uint dwNotificationTriggered;
            public IntPtr pszServiceNames;
        };

        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
        public struct SERVICE_STATUS_PROCESS
        {
            public uint dwServiceType;
            public uint dwCurrentState;
            public uint dwControlsAccepted;
            public uint dwWin32ExitCode;
            public uint dwServiceSpecificExitCode;
            public uint dwCheckPoint;
            public uint dwWaitHint;
            public uint dwProcessId;
            public uint dwServiceFlags;
        };

        [DllImport("advapi32.dll")]
        static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, uint dwDesiredAccess);

        [DllImport("advapi32.dll")]
        static extern IntPtr OpenSCManager(string machineName, string databaseName, uint dwAccess);

        [DllImport("advapi32.dll")]
        static extern uint NotifyServiceStatusChange(IntPtr hService, uint dwNotifyMask, IntPtr pNotifyBuffer);

        [DllImportAttribute("kernel32.dll")]
        static extern uint SleepEx(uint dwMilliseconds, bool bAlertable);

        [DllImport("advapi32.dll")]
        static extern bool CloseServiceHandle(IntPtr hSCObject);

        delegate void StatusChangedCallbackDelegate(IntPtr parameter);

        /// <summary> 
        /// Block until a service stops or is found to be already dead.
        /// </summary> 
        /// <param name="serviceName">The name of the service you would like to wait for.</param>
        public static void WaitForServiceToStop(string serviceName)
        {
            IntPtr hSCM = OpenSCManager(null, null, (uint)0xF003F);
            if (hSCM != IntPtr.Zero)
            {
                IntPtr hService = OpenService(hSCM, serviceName, (uint)0xF003F);
                if (hService != IntPtr.Zero)
                {
                    StatusChangedCallbackDelegate changeDelegate = ReceivedStatusChangedEvent;
                    SERVICE_NOTIFY notify = new SERVICE_NOTIFY();
                    notify.dwVersion = 2;
                    notify.pfnNotifyCallback = Marshal.GetFunctionPointerForDelegate(changeDelegate);
                    notify.ServiceStatus = new SERVICE_STATUS_PROCESS();
                    GCHandle notifyHandle = GCHandle.Alloc(notify, GCHandleType.Pinned);
                    IntPtr pinnedNotifyStructure = notifyHandle.AddrOfPinnedObject();
                    NotifyServiceStatusChange(hService, (uint)0x00000001, pinnedNotifyStructure);
                    SleepEx(uint.MaxValue, true);
                    notifyHandle.Free();
                    CloseServiceHandle(hService);
                }
                CloseServiceHandle(hSCM);
            }
        }

        public static void ReceivedStatusChangedEvent(IntPtr parameter)
        {

        }
    }
}

是将APC排队到托管我的托管线程的任何本机线程上,还是将APC直接委派给我的托管线程？我以为委托在那里确实可以处理这种情况,因此我们不必担心本地如何管理托管线程,但是我可能错了！

编辑：我想这是一个更令人满意的答案.

using System;
using System.Runtime.InteropServices;
using System.Threading;

namespace ServiceAssistant
{
    class ServiceHelper
    {

        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
        public class SERVICE_NOTIFY
        {
            public uint dwVersion;
            public IntPtr pfnNotifyCallback;
            public IntPtr pContext;
            public uint dwNotificationStatus;
            public SERVICE_STATUS_PROCESS ServiceStatus;
            public uint dwNotificationTriggered;
            public IntPtr pszServiceNames;
        };

        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
        public struct SERVICE_STATUS_PROCESS
        {
            public uint dwServiceType;
            public uint dwCurrentState;
            public uint dwControlsAccepted;
            public uint dwWin32ExitCode;
            public uint dwServiceSpecificExitCode;
            public uint dwCheckPoint;
            public uint dwWaitHint;
            public uint dwProcessId;
            public uint dwServiceFlags;
        };

        [DllImport("advapi32.dll")]
        static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, uint dwDesiredAccess);

        [DllImport("advapi32.dll")]
        static extern IntPtr OpenSCManager(string machineName, string databaseName, uint dwAccess);

        [DllImport("advapi32.dll")]
        static extern uint NotifyServiceStatusChange(IntPtr hService, uint dwNotifyMask, IntPtr pNotifyBuffer);

        [DllImportAttribute("kernel32.dll")]
        static extern uint SleepEx(uint dwMilliseconds, bool bAlertable);

        [DllImport("advapi32.dll")]
        static extern bool CloseServiceHandle(IntPtr hSCObject);

        delegate void StatusChangedCallbackDelegate(IntPtr parameter);

        /// <summary> 
        /// Block until a service stops or is found to be already dead.
        /// </summary> 
        /// <param name="serviceName">The name of the service you would like to wait for.</param>
        /// <param name="timeout">An amount of time you would like to wait for. uint.MaxValue is the default, and it will force this thread to wait indefinitely.</param>
        public static void WaitForServiceToStop(string serviceName, uint timeout = uint.MaxValue)
        {
            Thread.BeginThreadAffinity();
            GCHandle? notifyHandle = null;
            StatusChangedCallbackDelegate changeDelegate = ReceivedStatusChangedEvent;
            IntPtr hSCM = OpenSCManager(null, null, (uint)0xF003F);
            if (hSCM != IntPtr.Zero)
            {
                IntPtr hService = OpenService(hSCM, serviceName, (uint)0xF003F);
                if (hService != IntPtr.Zero)
                {
                    SERVICE_NOTIFY notify = new SERVICE_NOTIFY();
                    notify.dwVersion = 2;
                    notify.pfnNotifyCallback = Marshal.GetFunctionPointerForDelegate(changeDelegate);
                    notify.ServiceStatus = new SERVICE_STATUS_PROCESS();
                    notifyHandle = GCHandle.Alloc(notify, GCHandleType.Pinned);
                    IntPtr pinnedNotifyStructure = ((GCHandle)notifyHandle).AddrOfPinnedObject();
                    NotifyServiceStatusChange(hService, (uint)0x00000001, pinnedNotifyStructure);
                    SleepEx(timeout, true);
                    CloseServiceHandle(hService);
                }
                CloseServiceHandle(hSCM);
            }
            GC.KeepAlive(changeDelegate);
            if (notifyHandle != null)
            {
                ((GCHandle)notifyHandle).Free();
            }
            Thread.EndThreadAffinity();
        }

        public static void ReceivedStatusChangedEvent(IntPtr parameter)
        {

        }
    }
}

重新编辑！我想这是一个甚至更好的答案：

using System;
using System.Runtime.InteropServices;
using System.Threading;

namespace ServiceAssistant
{
    class ServiceHelper
    {

        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
        public class SERVICE_NOTIFY
        {
            public uint dwVersion;
            public IntPtr pfnNotifyCallback;
            public IntPtr pContext;
            public uint dwNotificationStatus;
            public SERVICE_STATUS_PROCESS ServiceStatus;
            public uint dwNotificationTriggered;
            public IntPtr pszServiceNames;
        };

        [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
        public struct SERVICE_STATUS_PROCESS
        {
            public uint dwServiceType;
            public uint dwCurrentState;
            public uint dwControlsAccepted;
            public uint dwWin32ExitCode;
            public uint dwServiceSpecificExitCode;
            public uint dwCheckPoint;
            public uint dwWaitHint;
            public uint dwProcessId;
            public uint dwServiceFlags;
        };

        [DllImport("advapi32.dll")]
        static extern IntPtr OpenService(IntPtr hSCManager, string lpServiceName, uint dwDesiredAccess);

        [DllImport("advapi32.dll")]
        static extern IntPtr OpenSCManager(string machineName, string databaseName, uint dwAccess);

        [DllImport("advapi32.dll")]
        static extern uint NotifyServiceStatusChange(IntPtr hService, uint dwNotifyMask, IntPtr pNotifyBuffer);

        [DllImportAttribute("kernel32.dll")]
        static extern uint SleepEx(uint dwMilliseconds, bool bAlertable);

        [DllImport("advapi32.dll")]
        static extern bool CloseServiceHandle(IntPtr hSCObject);

        delegate void StatusChangedCallbackDelegate(IntPtr parameter);

        /// <summary> 
        /// Block until a service stops, is killed, or is found to be already dead.
        /// </summary> 
        /// <param name="serviceName">The name of the service you would like to wait for.</param>
        /// <param name="timeout">An amount of time you would like to wait for. uint.MaxValue is the default, and it will force this thread to wait indefinitely.</param>
        public static void WaitForServiceToStop(string serviceName, uint timeout = uint.MaxValue)
        {
            // Ensure that this thread's identity is mapped, 1-to-1, with a native OS thread.
            Thread.BeginThreadAffinity();
            GCHandle notifyHandle = default(GCHandle);
            StatusChangedCallbackDelegate changeDelegate = ReceivedStatusChangedEvent;
            IntPtr hSCM = IntPtr.Zero;
            IntPtr hService = IntPtr.Zero;
            try
            {
                hSCM = OpenSCManager(null, null, (uint)0xF003F);
                if (hSCM != IntPtr.Zero)
                {
                    hService = OpenService(hSCM, serviceName, (uint)0xF003F);
                    if (hService != IntPtr.Zero)
                    {
                        SERVICE_NOTIFY notify = new SERVICE_NOTIFY();
                        notify.dwVersion = 2;
                        notify.pfnNotifyCallback = Marshal.GetFunctionPointerForDelegate(changeDelegate);
                        notify.ServiceStatus = new SERVICE_STATUS_PROCESS();
                        notifyHandle = GCHandle.Alloc(notify, GCHandleType.Pinned);
                        IntPtr pinnedNotifyStructure = notifyHandle.AddrOfPinnedObject();
                        NotifyServiceStatusChange(hService, (uint)0x00000001, pinnedNotifyStructure);
                        SleepEx(timeout, true);
                    }
                }
            }
            finally
            {
                // Clean up at the end of our operation, or if this thread is aborted.
                if (hService != IntPtr.Zero)
                {
                    CloseServiceHandle(hService);
                }
                if (hSCM != IntPtr.Zero)
                {
                    CloseServiceHandle(hSCM);
                }
                GC.KeepAlive(changeDelegate);
                if (notifyHandle != default(GCHandle))
                {
                    notifyHandle.Free();
                }
                Thread.EndThreadAffinity();
            }
        }

        public static void ReceivedStatusChangedEvent(IntPtr parameter)
        {

        }
    }
}

解决方法:

是的,有可能成为这些问题的受害者.在这种特殊情况下,很难.当本机框架位于托管线程的堆栈上时,主机无法将托管线程切换到其他OS线程,并且由于您立即p / invoke SleepEx,因此主机用于切换托管线程的窗口在两个p /调用.但是,当您需要在同一个OS线程上进行p /调用并且存在Thread.BeginThreadAffinity()来覆盖这种情况时,有时还是不太可能的.

现在是关于APC的问题.请记住,操作系统对托管线程一无所知.因此,当APC执行可警报的操作时,它将被传递到原始本机线程中.在这种情况下,我不知道CLR主机如何创建托管上下文,但是如果托管线程与OS线程是一对一的,则回调可能会使用托管线程的上下文.

更新您的新代码现在更加安全,但是您在另一个方向上走得太远了：

1)不需要使用线程相似性包装整个代码.仅包装确实需要在同一OS线程上运行的两个p /调用(通知和睡眠).不管是否使用有限的超时都没有关系,因为线程亲和性要解决的问题是两个p /调用之间从托管到OS线程的迁移.回调不应该假设它无论如何都在任何特定的托管线程上运行,因为它几乎可以安全地执行,而应该执行的很少：互锁的操作,设置事件和完成TaskCompletionSources就是这样.

2)GCHandle是一个简单的IntPtr大小的结构,可以比较相等性.代替使用GCHandle ?,而是使用普通的GCHandle并与default(GCHandle)进行比较.此外,GCHandle？在一般原则上对我来说似乎有些可疑.

3)当您关闭服务手柄时,通知将停止. SCM手柄可以保持打开状态,您可能需要保留它以便下次检查.

// Thread.BeginThreadAffinity();
// GCHandle? notifyHandle = null;
var hSCM  = OpenSCManager(null, null, (uint)0xF003F);
if (hSCM != IntPtr.Zero)
{
    StatusChangedCallbackDelegate changeDelegate = ReceivedStatusChangedEvent;
    var notifyHandle = default(GCHandle);

    var hService  = OpenService(hSCM, serviceName, (uint)0xF003F);
    if (hService != IntPtr.Zero)
    {
        ...
        notifyHandle = GCHandle.Alloc(notify, GCHandleType.Pinned);
        var addr = notifyHandle.AddrOfPinnedObject();
        Thread.BeginThreadAffinity();
        NotifyServiceStatusChange(hService, (uint)0x00000001, addr);
        SleepEx(timeout, true);
        Thread.EndThreadAffinity();
        CloseServiceHandle(hService);
    }

    GC.KeepAlive(changeDelegate);
    if (notifyHandle != default(GCHandle))
        notifyHandle.Free();

    CloseServiceHandle(hSCM);
}

另外,为了尽可能安全,如果代码将长时间运行,或者正在编写库,则必须使用受约束的区域和/或SafeHandles来确保即使线程为流产了.查看所有绕过的BCL代码,例如System.Threading.Mutex(使用Reflector或CLR源代码).至少,请使用SafeHandles并尝试/最后尝试释放GCHandle和结束线程关联.

至于与回调相关的问题,这些只是正常的多线程问题的一种坏情况：死锁,活动锁,优先级反转等.这种APC回调最糟糕的事情是(除非您自己阻塞整个线程,直到它会发生,在这种情况下,仅阻塞本机代码会更容易),您无需控制它的发生时间：您的线程可能位于BCL的深处,等待I / O,信号事件等,这是很难推断程序可能处于的状态.

内容总结

以上是互联网集市为您收集整理的从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？全部内容，希望文章能够帮你解决从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/677569.html

来源：【匿名】

【上一篇】C#-强制转换泛型参数【下一篇】assemblyinfo.csC#Assembly类访问程序集信息

更多 ►

【从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？】教程文章相关的互联网学习教程文章

asp.net（c#）中如何在前端用js写条件查询，且不用调用存储过程

前端页面（源）： <dx:ASPxButton ID="ASPxButton_Select" runat="server" Text="查询" AutoPostBack="false"> <ClientSideEvents Click="bt_select" /> </dx:ASPxButton> js部分： function bt_select() { //alert(cb_goodstype.GetValue()); updateGrid();...

c# WPF客户端调用WebAPI并转换成List【代码】

利用HttpClient、JsonConvert实现。引用Newtonsoft.Json.dll和System.Net.Http。举个例子：从webapi中获取设备列表。publicpartialclass MainWindow : Window{public MainWindow(){InitializeComponent();}privatevoid Button_Click(object sender, RoutedEventArgs e){var list= GetEquipList<EquipModel>(1);}public List<T> GetEquipList<T>(int orgId){string url = "http://127.0.0.1/K3Cloud/BAH.TEST.APP.PCService.EquipSe...

C#调用WINDOWS API 示例

一、调用Windows API。　C#下调用Windows API方法如下：　1、引入命名空间：using System.Runtime.InteropServices;　2、引用需要使用的方法，格式：[DllImport("DLL文件")]方法的声明;　[DllImport("user32.dll")]private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);　[DllImport("user32.dll")]private static extern bool SetForegroundWindow(IntPtr hWnd);　[DllImport("user32.dll")]private static extern ...

JS和C#访问遇到QueryInterface调用出错

在原来的WinForm里，我们只要在窗体类的头部添加属性[System.Runtime.InteropServices.ComVisibleAttribute(true)]，然后 webBrowser1.ObjectForScripting = this；这样设置完后，页面上的JS就能访问窗体类的方法了，但是添加WeifenLuo.WinFormsUI.Docking.DockContent作为窗体的父类后如果这样设置却会出现如下提示：执行了QueryInterface调用，请求提供 COM 可见的托管类“自己的类”的默认IDispatch 接口。不过，由于该类没有显...

c#继承中的函数调用

首先看下面的代码:?1234567891011121314151617using System; namespace Test{ publicclassBase { publicvoidPrint() { Console.WriteLine(Operate(8, 4)); } protectedvirtual intOperate(intx, inty) { returnx + y; } }}?12345678910namespace Test{ publicclassOnceChild : Base { protectedoverride intOperate(intx, inty) {...

c# 调用方法超时直接返回的功能【代码】

C#实现函数的超时退出功能主要是用到了System.Threading.Tasks.TaskFactory的StartNew()函数 privatestaticvoid Main(string[] args){Console.WriteLine("Begin:" + DateTime.Now);bool ret = Process(string.Empty, 10000);Console.WriteLine("Result={0}", ret);Console.WriteLine("End:" + DateTime.Now);Console.WriteLine("Press any key to exit...");Console.ReadKey(true);}privatestaticbool Process(string param, int t...

C#解决“System.Threading.ThreadStateException:“在可以调用 OLE 之前，必须将当前线程设置为单线程单元(STA)模式。请确保您的 Main 函数带有 STAThreadAttribute 标记。只有将调试程序附加到该进程才会引发此异常”的异常【代码】

“System.Threading.ThreadStateException:“在可以调用 OLE 之前，必须将当前线程设置为单线程单元(STA)模式。请确保您的 Main 函数带有 STAThreadAttribute 标记。只有将调试程序附加到该进程才会引发此异常”的异常Thread t = new Thread((ThreadStart)(() => {// 将出现这个异常的语句放到这里面 } )); t.SetApartmentState(ApartmentState.STA); t.Start(); t.Join(); 原文：https://www.cnblogs.com/prodigal-son/p/1420614...

C# 调用存储过程【图】

下面以调用：Sql Server 分页存储过程为例调用代码如下： string MyConn = "server=数据库服务器Ip;uid=数据库用户名;pwd=密码;database=数据库名称;Trusted_Connection=no";SqlConnection MyConnection = new SqlConnection(MyConn); SqlDataAdapter da = new SqlDataAdapter();da.SelectCommand = new SqlCommand();da.SelectCommand.Connection = MyConnection;da.SelectCommand.CommandText = "proc_ListPageInt";da.SelectCom...

【新年送礼】国内第一部C#.Net调用Matlab进行混合编程的视频教程【彻底免费无注册码】

其他混合编程文章1【原创】Matlab.NET混合编程技巧之——直接调用Matlab内置函数(附源码)2.【原创】Matlab.NET混合编程技巧之——找出Matlab内置函数 3.【原创】Matlab与.NET混编解决人脸识别问题 4.【原创】Matlab与.NET基于类型安全的接口编程入门5.【原创分享】Matlab.NET混编调用Figure窗体一、视频说明　　2014年的5.1，我将这套视频教程进行了免费下载，免费注册开放：【5.1送礼】国内第一部Matlab和C#.Net混合编程入门...

C# 8 函数调用常用类

函数：能够独立完成某个功能的模块。好处：1.结构更清析（编写、维护方便）。2.代码重用。3.分工开发。四要素：名称，输入（参数），输出（返回的类型），加工（函数体）语法：返回类型函数名(参数类型参数名,....){函数体} 函数调用：[数据类型变量名 = ]函数(参数); 函数调用时：调用的参数和函数定义的参数保持一对待：个数，类型，对应。形参：形式参数。——函数定义的参数。实参：实际参数。——函数调用的参数。实参、...

性能优化之——.NET(C#)调用webService获取客户端IP地址所属区域(异步回调)（二）【代码】【图】

朋友们这次分享的是异步回调不是异步调用哦！请注意喽！功能描述，接口地址，方法名称以及参数说明，同上篇：.NET(C#)调用webService获取客户端IP地址所属区域(非异步)（一）（LZ比较懒，不想写太多哦！(⊙０⊙)）实现代码如下： 1namespace main2{3class Program4 {5publicstaticstring Result = string.Empty;6 7staticvoid Main(string[] args)8 {910 Stopwatch sw = Stopwatch.StartNew(); 1112string s...

C# 调用 Web Service【图】

Web Service也叫XML Web Service WebService是一种可以接收从Internet或者Intranet上的其它系统中传递过来的请求，轻量级的独立的通讯技术。是:通过SOAP在Web上提供的软件服务，使用WSDL文件进行说明，并通过UDDI进行注册。XML：(Extensible Markup Language)扩展型可标记语言。面向短期的临时数据处理、面向万维网络，是Soap的基础。Soap：(Simple Object Access Protocol)简单对象存取协议。是XML Web Service 的通信协议。当用户...

C#调用默认浏览器打开网页的方法

1.最常用的页面跳转（原窗口被替代）：Response.Redirect("XXX.aspx");2.利用url地址打开本地网页或互联网：Respose.Write("<script language=‘javascript‘>window.open(‘"+ url+"‘);</script>");3.原窗口保留再新打开另一个页面（浏览器可能阻止，需要解除）：Response.Write("<script>window.open(‘XXX.aspx‘,‘_blank‘)</script>");4.效果同1中的另一种写法：Response.Write("<script>window.location=‘XXX.aspx‘</scr...

关于Set Nocount ON的性能 |c#调用存储过程的返回值总是-1

原文地址：http://www.tuicool.com/articles/qe6BZbR也许因为它太过于简单，自己一直没能好好关注这个语句，只记得＂只是＂提高点性能而已．有时会在存储过程中写上几句，有时也会懒得去敲这几个字母．但是．他们SET NOCOUNT ON 和SET NOCOUNT OFF 之间到底有多大的区别吗？前天一时好奇．终于想弄清楚他们之间性能有多大区别．在google一遍，找了几篇文章．我们可以得出一些结论．How NOCOUNT affects ADO.NET （NOCOUNT对ADO.NET...

[转]C# WinForm动态调用远程Web服务

本文转自：http://blog.csdn.net/muyangjun/article/details/79308711、添加服务引用2、在弹出的添加服务引用对话框地址栏中输入WebService地址，如：http://localhost:6521/WebSite1/Service.asmx?WSDL3、输入命名空间名称或保持默认4、定义SoapClient变量 WebService.ServiceSoapClient SoapClient = new WindowsFormsApplication1.WebService.ServiceSoapClient();5、将新的重新配置WebService的URL ...

首页 / C# / 从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？

从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？

内容导读

内容图文

内容总结

内容备注

内容手机端

【从C#进行P / Invoke调用时,异步过程调用如何处理已封送的委托？】教程文章相关的互联网学习教程文章

异步 - 相关标签

C# - 技术教程分类

C# - 最新教程

C# - 最热教程