Understanding Classic COM Interoperability With .NET Applications

最新推荐文章于 2024-09-10 10:44:51 发布
最新推荐文章于 2024-09-10 10:44:51 发布
阅读量836 收藏
点赞数
分类专栏： C++/CLI&& C#&&DotNET 文章标签： .net null destructor object wizard dll

最近在研究C++ 与C# 的interoperability, 所以收藏了一些资料：

前言:为了介绍C#写界面，C++写算法的快捷交互开发方式，首先介绍c++，C#内部的DLL，COM调用。

一，COM
COM (Component Object Model),微软为提高代码的可从用性而开发的组件对象模型的软件架构，在windows系统的开发中大量的使用了这种技术，使用这种技术我们尽可能的把我们的软件划分位许多组件，通过组件的组合调用最总实现软件的目的，COM的使用不仅大大的提高了代码的可从用性，而且减小了代码间的耦合。更多的关于OLE，COM，COM+，DCOM，ActiveX的概念。

二，COM的创建
一般COM的创建有2中方法，使用ATL Wizard 和不使用ATL。

1）使用ATL Wizard创建COM非常的简单，可以参考下面2个链接，分别使用ATL6.0和ATL7.0，最新的类似：
     ATL7.0 COM: http://www.codeproject.com/atl/SimpleDlls.asp
     ATL6.0 com: http://www.codeproject.com/atl/com_atl.asp

2）不使用ATL，当然更没有Wizard，只有手动的一步一步的实现，不过这也是学习COM最好的方法和必经之路。可以参考：
     http://www.codeproject.com/com/LocalCOMServerClient.asp
    具体的步骤如下：
    1）建立一个Win32的DLL。例如CarLocalServer。
    2）首先加入IDL接口描述文件CarLocalServerTypeInfo.idl，编译后会生成4个文件CarLocalServerTypeInfo_h.h，CarLocalServerTypeInfo_i.cpp，CarLocalServerTypeInfo_p.cpp，      dlldata.cpp 。
    

import  " oaidl.idl " ;
import  " ocidl.idl " ;

 //  define IStats interface
[ object , uuid(FE78387F - D150 - 4089 - 832C - BBF02402C872),
 oleautomation, helpstring( " Get the status information about this car " )]
interface IStats : IUnknown
{
   HRESULT DisplayStats();
   HRESULT GetPetName([out,retval] BSTR *  petName);
};

 //  define the IEngine interface
[ object , uuid(E27972D8 - 717F - 4516 - A82D - B688DC70170C),
 oleautomation, helpstring( " Rev your car and slow it down " )]
interface IEngine : IUnknown
{
   HRESULT SpeedUp();
   HRESULT GetMaxSpeed([out,retval]  int *  maxSpeed);
   HRESULT GetCurSpeed([out,retval]  int *  curSpeed);
};

 //  define the ICreateMyCar interface
[ object , uuid(5DD52389 - B1A4 - 4fe7 - B131 - 0F8EF73DD175),
 oleautomation, helpstring( " This lets you create a car object " )]
interface ICreateMyCar : IUnknown
{
   HRESULT SetPetName([in]BSTR petName);
   HRESULT SetMaxSpeed([in]  int  maxSp);
};

 //  library statement
[uuid(957BF83F - EE5A - 42eb - 8CE5 - 6267011F0EF9), version( 1.0 ),
 helpstring( " Car server with typeLib " )]
library CarLocalServerLib
{
   importlib( " stdole32.tlb " );
   [uuid(1D66CBA8 - CCE2 - 4439 - 8596 - 82B47AA44E43)]
   coclass MyCar
   {
      [default] interface ICreateMyCar;
      interface IStats;
      interface IEngine;
   };
};


    3） 加入生命周期管理类managesycle.h，
 

#pragma once

class CManageSycle
{
 public :
    CManageSycle(void);
    ~CManageSycle(void);

    static void InObject()  { ++ m_nObject;}
    static void DeObject()  { -- m_nObject;}
    static bool IsZeroObject() { return m_nObject == 0  ;}
    static void InLock()  { ++ m_nLock;}
    static void DeLock()  { -- m_nLock;}
    static bool IsZeroLock() { return m_nLock == 0  ; }
 private :
    static ULONG m_nObject;
    static ULONG m_nLock;
};

managesycle.cpp实现文件：

#include  " StdAfx.h "
#include  " managesycle.h "
ULONG CManageSycle::m_nObject = 0 ;
ULONG CManageSycle::m_nLock = 0 ;
CManageSycle::CManageSycle(void)
{
}

CManageSycle::~CManageSycle(void)
{
}


    4）加入真正的com的接口的实现类，MyCar.h （除了实现COM的接口，还必须实现IUnKnown接口）


#pragma once

#include  " unknwn.h "
#include  " CarLocalServerTypeInfo_h.h "

const   int  MAX_SPEED  =   500 ;
 const   int  MAX_NAME_LENGTH  =   20 ;

class MyCar : 
     public  IEngine, 
     public  ICreateMyCar, 
     public  IStats  
{
 public :
    MyCar();
    virtual ~MyCar();

     //  IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **  pIFace);
    STDMETHODIMP_(DWORD)AddRef();
    STDMETHODIMP_(DWORD)Release();

     //  IEngine
    STDMETHODIMP SpeedUp();
    STDMETHODIMP GetMaxSpeed( int *  maxSpeed);
    STDMETHODIMP GetCurSpeed( int *  curSpeed);
    
     //  IStats
    STDMETHODIMP DisplayStats();
    STDMETHODIMP GetPetName(BSTR *  petName);

     //  ICreateMyCar
    STDMETHODIMP SetPetName(BSTR petName);
    STDMETHODIMP SetMaxSpeed( int  maxSp);

 private :
    DWORD    m_refCount;
    BSTR    m_petName;
     int         m_maxSpeed;
     int         m_currSpeed;
};

MyCar.cpp

#include  " stdafx.h "
#include  < stdio.h >  

#include  " CarLocalServerTypeInfo_i.c "
#include  " MyCar.h "
#include  " ManageSycle.h "

//
//  Construction / Destruction
 //
MyCar::MyCar() : m_refCount( 0 ), m_currSpeed( 0 ), m_maxSpeed( 0 )
{
    m_refCount = 0 ;
    CManageSycle::InObject();
    m_petName  =  SysAllocString(L " Default Pet Name " );
    
}

MyCar::~MyCar()
{
    CManageSycle::DeObject();
     if (m_petName) SysFreeString(m_petName);
    MessageBox( NULL ,
    L " MyCar is being distructed. Make sure you see this message, if not, you might have memory leak! " ,
    L " Destructor " ,MB_OK | MB_SETFOREGROUND);
}

 //  IUnknown
STDMETHODIMP MyCar::QueryInterface(REFIID riid, void **  pIFace)
{
     //  Which aspect of me  do  they want?
     if (riid  ==  IID_IUnknown)
    {
         * pIFace  =  (IUnknown * )(IEngine * )this;
         //  MessageBox( NULL ,  " Handed out IUnknown " , " QI " ,MB_OK | MB_SETFOREGROUND);
    }
    
     else   if (riid  ==  IID_IEngine)
    {
         * pIFace  =  (IEngine * )this;
         //  MessageBox( NULL ,  " Handed out IEngine " , " QI " ,MB_OK | MB_SETFOREGROUND);
    }
    
     else   if (riid  ==  IID_IStats)
    {
         * pIFace  =  (IStats * )this;
         //  MessageBox( NULL ,  " Handed out IStats " , " QI " ,MB_OK | MB_SETFOREGROUND);
    }
    
     else   if (riid  ==  IID_ICreateMyCar)
    {
         * pIFace  =  (ICreateMyCar * )this;
         //  MessageBox( NULL ,  " Handed out ICreateMyCar " , " QI " ,MB_OK | MB_SETFOREGROUND);
    }
     else
    {
         * pIFace  =   NULL ;
        return E_NOINTERFACE;
    }

    ((IUnknown * )( * pIFace)) -> AddRef();
    return S_OK;
}

STDMETHODIMP_(DWORD) MyCar::AddRef()
{
     ++ m_refCount;
    return m_refCount;
}

STDMETHODIMP_(DWORD) MyCar::Release()
{
     if ( -- m_refCount  ==   0 )
    {
        delete this;
        return  0 ;
    }
     else
        return m_refCount;
}

 //  IEngine
STDMETHODIMP MyCar::SpeedUp()
{
    m_currSpeed  +=   10 ;
    return S_OK;
}

STDMETHODIMP MyCar::GetMaxSpeed( int *  maxSpeed)
{
     * maxSpeed  =  m_maxSpeed;
    return S_OK;
}

STDMETHODIMP MyCar::GetCurSpeed( int *  curSpeed)
{
     * curSpeed  =  m_currSpeed;
    return S_OK;
}


 //  IStats
STDMETHODIMP MyCar::DisplayStats()
{
     //  Need  to  transfer a BSTR  to  a char  array .
    char buff[MAX_NAME_LENGTH];
    WideCharToMultiByte(CP_ACP,  NULL , m_petName,  - 1 , buff, 
                        MAX_NAME_LENGTH,  NULL ,  NULL );

     // MessageBox( NULL , buff, L " Pet Name " ,MB_OK | MB_SETFOREGROUND);
    memset(buff,  0 , sizeof(buff));
    sprintf(buff,  " %d " , m_maxSpeed);
     // MessageBox( NULL , buff,L " Max Speed " , MB_OK| MB_SETFOREGROUND);
    return S_OK;
}

STDMETHODIMP MyCar::GetPetName(BSTR *  petName)
{
     * petName  =  SysAllocString(m_petName);
    return S_OK;
}


 //  ICreateMyCar
STDMETHODIMP MyCar::SetPetName(BSTR petName)
{
    SysReAllocString( & m_petName, petName);
    return S_OK;
}

STDMETHODIMP MyCar::SetMaxSpeed( int  maxSp)
{
     if (maxSp  <  MAX_SPEED)
        m_maxSpeed  =  maxSp;
    return S_OK;
}


    5）加入工厂类MyCarClassFactory.h，（实现IUnKnown接口和IClassFactory接口）

//  the class  object  (class factory)  for  CoMyCar class

#pragma once

class MyCarClassFactory :  public  IClassFactory
{
 public :
    MyCarClassFactory();
    virtual ~MyCarClassFactory();

     //  IUnknown
    STDMETHODIMP QueryInterface(REFIID riid,void **  pIFace);
    STDMETHODIMP_(ULONG)AddRef();
    STDMETHODIMP_(ULONG)Release();

     //  IClassFactory
    STDMETHODIMP LockServer(BOOL fLock);
    STDMETHODIMP CreateInstance(LPUNKNOWN pUnkOuter,REFIID riid,void **  ppv);

 private :

    ULONG m_refCount;

};

MyCarClassFactory.cpp

#include  " stdafx.h "
#include  " MyCar.h "
#include  " MyCarClassFactory.h "
#include  " locks.h "
#include  " ManageSycle.h "

MyCarClassFactory::MyCarClassFactory()
{
    m_refCount  =   0 ;
}

MyCarClassFactory::~MyCarClassFactory()
{
    MessageBox( NULL ,
    L " MyCarClassFactory is being distructed. Make sure you see this message, if not, you might have memory leak! " ,
    L " Destructor " ,MB_OK | MB_SETFOREGROUND);
}

STDMETHODIMP_(ULONG) MyCarClassFactory::AddRef()
{
     // return  ++ m_refCount;
    return  10 ;
}

STDMETHODIMP_(ULONG) MyCarClassFactory::Release()
{
     /*
     if  (  -- m_refCount  ==   0  )
    {
        delete this;
        return  0 ;
    }
    return m_refCount;
     */
    return  20 ;
}

STDMETHODIMP MyCarClassFactory::QueryInterface(REFIID riid,void **  pIFace)
{
     if  ( riid  ==  IID_IUnknown )
         * pIFace  =  (IUnknown * )this;
     else   if  ( riid  ==  IID_IClassFactory )
         * pIFace  =  (IClassFactory * )this;
     else
    {
         * pIFace  =   NULL ;
        return E_NOINTERFACE;
    }
    ((IUnknown * )( * pIFace)) -> AddRef();
    return S_OK;
}

STDMETHODIMP MyCarClassFactory::LockServer(BOOL fLock)
{
    (VARIANT_TRUE  ==  fLock) ? CManageSycle::InLock() : CManageSycle::DeLock();
    return S_OK;
}

STDMETHODIMP MyCarClassFactory::CreateInstance(LPUNKNOWN pUnkOuter,REFIID riid,void **  ppv)
{
     if  ( pUnkOuter ! =   NULL  ) return CLASS_E_NOAGGREGATION;

    MyCar *  pMyCarObj  =   NULL ;
    HRESULT hr;

    pMyCarObj  =   new  MyCar();
    hr  =  pMyCarObj -> QueryInterface(riid,ppv);

     if  ( FAILED(hr) ) delete pMyCarObj;
    return hr;
}


    6）实现COM入口和自注册函数CarLocalServer.cpp，

//  CarLocalServer.cpp : Defines the entry point  for  the DLL application.
 //

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

#include  " CarLocalServerTypeInfo_h.h "
// #include  " CarLocalServerTypeInfo_i.c "
#include  " MyCarClassFactory.h "     
#include  " ManageSycle.h "

using namespace std;

#ifdef _MANAGED
#pragma managed(push, off)
#endif

HMODULE g_hmodule;

BOOL APIENTRY DllMain( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                     )
{
    g_hmodule  =  static_cast < HMODULE > (hModule);
    return  TRUE ;
}


STDAPI DllCanUnloadNow()
{
    bool bDllCanUnloadNow  =  CManageSycle::IsZeroObject()  &&  CManageSycle::IsZeroLock();
    return bDllCanUnloadNow ? S_OK : S_FALSE;
}

STDAPI DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *  ppv)
{
     * ppv  =   NULL ;
     if (__uuidof(MyCar) ! =  rclsid)
    {
        return E_NOINTERFACE;
    }

    MyCarClassFactory *  pBirdFactory  =   new  MyCarClassFactory();
     if ( NULL   ==  pBirdFactory)
    {
        return E_OUTOFMEMORY;
    }

    HRESULT hr  =  pBirdFactory -> QueryInterface(riid,ppv);
     if (FAILED(hr))
    {
        delete pBirdFactory;
    }
    return hr;
}

STDAPI DllRegisterServer()
{
    HKEY hRoot, hNew;
    ::RegOpenKey(HKEY_CLASSES_ROOT,L " CLSID " , & hRoot);
    ::RegCreateKey(hRoot,L " {1F0A9759-FCBE-4870-8336-971BD19A7452}//InprocServer32 " , & hNew);
    wchar_t strFile[MAX_PATH];
    ::GetModuleFileName(g_hmodule,strFile,MAX_PATH);
    ::RegSetValue(hNew, NULL ,REG_SZ,strFile,MAX_PATH);
    ::RegCloseKey(hRoot);
    return S_OK;
}

STDAPI DllUnregisterServer()
{
    HKEY hRoot;
    ::RegOpenKey(HKEY_CLASSES_ROOT,L " CLSID " , & hRoot);
    ::RegDeleteKey(hRoot,L " {1F0A9759-FCBE-4870-8336-971BD19A7452} " );
    ::RegDeleteKey(hRoot,L " {1F0A9759-FCBE-4870-8336-971BD19A7452}//InprocServer32 " );
    ::RegCloseKey(hRoot);
    return S_OK;
}
#ifdef _MANAGED
#pragma managed(pop)
#endif


    7）增加def到处文件CarLocalServer.def，

LIBRARY     " CarLocalServer "

EXPORTS
    DllCanUnloadNow                 PRIVATE
    DllGetClassObject                PRIVATE
    DllRegisterServer                PRIVATE
    DllUnregisterServer             PRIVATE


  

三，COM的调用过程
通过一个创建COM组件的最小框架结构，然后看一看其内部处理流程是怎样的

　　　　IUnknown *pUnk=NULL;
　　　　IObject *pObject=NULL;
　　　　CoInitialize(NULL);
　　　　CoCreateInstance(CLSID_Object, CLSCTX_INPROC_SERVER, NULL, IID_IUnknown, (void**)&pUnk);
　　　　pUnk->QueryInterface(IID_IOjbect, (void**)&pObject);
　　　　pUnk->Release();
　　　　pObject->Func();
　　　　pObject->Release();
　　　　CoUninitialize();

这就是一个典型的创建COM组件的框架，不过我的兴趣在CoCreateInstance身上，让我们来看看它内部做了一些什么事情。
以下是它内部实现的一个伪代码:

　　　　CoCreateInstance(....)
　　　　{
　　　　.......
　　　　IClassFactory *pClassFactory=NULL;
　　　　CoGetClassObject(CLSID_Object, CLSCTX_INPROC_SERVER, NULL, IID_IClassFactory, (void **)&pClassFactory);
　　　　pClassFactory->CreateInstance(NULL, IID_IUnknown, (void**)&pUnk);
　　　　pClassFactory->Release();
　　　　........
　　　}

这段话的意思就是先得到类厂对象，再通过类厂创建组件从而得到IUnknown指针。继续深入一步，看看CoGetClassObject的内部伪码：

　　　CoGetClassObject(.....)
　　　{
　　　　//通过查注册表CLSID_Object，得知组件DLL的位置、文件名
　　　　//装入DLL库
　　　　//使用函数GetProcAddress(...)得到DLL库中函数DllGetClassObject的函数指针。
　　　　//调用DllGetClassObject
　　　}
DllGetClassObject是干什么的，它是用来获得类厂对象的。只有先得到类厂才能去创建组件.
　　　　下面是DllGetClassObject的伪码：
　　　　DllGetClassObject(...)
　　　　{
　　　　......
　　　　CFactory* pFactory= new CFactory; //类厂对象
　　　　pFactory->QueryInterface(IID_IClassFactory, (void**)&pClassFactory);
　　　　//查询IClassFactory指针
　　　　pFactory->Release();
　　　　......
　　　　}
　　　　CoGetClassObject的流程已经到此为止，现在返回CoCreateInstance，看看CreateInstance的伪码：
　　　　CFactory::CreateInstance(.....)
　　　　{
　　　　...........
　　　　CObject *pObject = new CObject; //组件对象
　　　　pObject->QueryInterface(IID_IUnknown, (void**)&pUnk);
　　　　pObject->Release();
　　　　...........
　　　　}


四，COM的调用方法
对上面手动创建的COM的调用实例：

int  main()
{
     //  initialize the COM runtime
    cout  <<   " Initialize the COM runtime " ;
    CoInitialize( NULL );
    cout  <<   " success. "   <<  endl;

     //  declare variables
    HRESULT hr;
    IClassFactory *  pICF  =   NULL ;
    ICreateMyCar *   pICreateMyCar  =   NULL ;
    IEngine *        pIEngine  =   NULL ;
    IStats *         pIStats  =   NULL ;

    cout  <<  endl  <<   " Get the class factory interface for the Car class " ;
    hr  =  CoGetClassObject(CLSID_MyCar,CLSCTX_LOCAL_SERVER, NULL ,IID_IClassFactory,(void ** ) & pICF);
     if  ( FAILED(hr) )
    {
        cout << " fail " ;
         exit ( 1 );
    }
     else  cout  <<   " success. "   <<  endl;
    
    cout  <<   " Create the Car object and get back the ICreateMyCar interface " ;
    hr  =  pICF -> CreateInstance( NULL ,IID_ICreateMyCar,(void ** ) & pICreateMyCar);
     if  ( FAILED(hr) )
    {
         // ShowErrorMessage( " CoGetClassObject() " ,hr);
         exit ( 1 );
    }
     else  cout  <<   " success. "   <<  endl;
    
     //   set  parameters  on  the car
    cout  <<  endl  <<   " Set different parameters on the car " ;
    pICreateMyCar -> SetMaxSpeed( 30 );
    BSTR carName  =  SysAllocString(OLESTR( " COMCar?! " ));
    pICreateMyCar -> SetPetName(carName);
    SysFreeString(carName);
    cout  <<   " success. "   <<  endl;

    cout  <<  endl  <<   " Query the IStats interface " ;
    pICreateMyCar -> QueryInterface(IID_IStats,(void ** ) & pIStats);
    cout  <<   " success. "   <<  endl;

    cout  <<  endl  <<   " Use the IStats interface to display the status of the car: "   <<  endl;
    pIStats -> DisplayStats();

    cout  <<  endl  <<   " Query the IEngine interface " ;
    pICreateMyCar -> QueryInterface(IID_IEngine,(void ** ) & pIEngine);
    cout  <<   " success. "   <<  endl;

    cout  <<  endl  <<   " Start to use the engine "   <<  endl;
     int  curSp  =   0 ;
     int  maxSp  =   0 ;
    pIEngine -> GetMaxSpeed( & maxSp);
     do
    {
        pIEngine -> SpeedUp();
        pIEngine -> GetCurSpeed( & curSp);
        cout  <<   " current speed is:  "   <<  curSp  <<  endl;
    }  while  (curSp  <=  maxSp);

    cout  <<  endl  <<   " Report status again:  "   <<  endl;
    pIStats -> DisplayStats();

     if  ( pICF )         pICF -> Release();
     if  ( pICreateMyCar) pICreateMyCar -> Release();
     if  ( pIStats )      pIStats -> Release();
     if  ( pIEngine )     pIEngine -> Release();

    cout  <<  endl  <<   " Close the COM runtime " ;
    CoUninitialize();
    cout  <<   " success. "   <<  endl;

    return  0 ;
}


方法一：向上面的调用，通过包含#include "../CarLocalServer/CarLocalServerTypeInfo_h.h"和#include "../CarLocalServer/CarLocalServerTypeInfo_i.c"

方法二：使用#import导入tlb

可以使用： CComBSTR ，CComPtr<> 和 CComQIPtr<> 等来简化调用。

五，总结
COM比一般的DLL有很多的优点，COM没有重名问题，因为根本不是通过函数名来调用函数，而是通过虚函数表，自然也不会有函数名修饰的问题。路径问题也不复存在，因为是通过查注册表来找组件的，放在什么地方都可以，即使在别的机器上也可以。也不用考虑和EXE的依赖关系了，它们二者之间是松散的结合在一起，可以轻松的换上组件的一个新版本，而应用程序混然不觉。

但是COM仍然是有问题的，比如说版本控制的问题，.NET将逐步代替COM的使用。 

 

codeproject上面有一篇比较好的文章：

http://www.codeproject.com/dotnet/cominterop.asp

maliang1225
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Understanding Classic COM Interoperability w/.NET Applicatio
02-23
经典COM（Component Object Model）与.NET应用程序的交互性是软件开发中的一个重要概念，尤其是在处理旧有系统升级或集成新功能时。这篇文档将深入探讨如何使.NET应用程序与COM组件进行有效的沟通，以便充分利用已有...
COM and .NET Interoperability.pdf
09-03
《COM and .NET Interoperability》这本书由Andrew Troelsen撰写，是针对新老开发者的一本深入浅出介绍COM与.NET互操作性的参考书。全书共816页，通过详尽的内容帮助读者掌握如何在实际开发工作中有效地将COM和.NET...
.NET and COM: The Complete Interoperability Guide
05-12
* Using COM Components Within the .NET Framework * Using .NET Framework Components from COM * Designing Good .NET Framework Components for COM Clients * Designing Good COM Components for .NET ...
Developing Applications With Visual Studio.Net
04-08
DEVELOPING APPLICATIONS WITH VISUAL STUDIO.NET is an in-depth guide that takes Windows programming to the next level: creating .NET applications that leverage the prior knowledge and experience of C++...
在VB.net中，TimeSpan有什么属性与方法
fsyuheduo的博客
09-09 612
==标题==在VB.net中，TimeSpan有什么属性与方法==正文==在 VB.NET 中，`TimeSpan` 结构表示时间间隔，即一段时间，而不表示特定的时间点。`TimeSpan` 提供了多种属性来获取时间间隔的各个组成部分，以及一些方法来操作这些时间间隔。1. TimeSpan 的属性以下是一些常见的 `TimeSpan` 属性：- `Days`: 返回 `TimeSpan` 对象中的...
.NET 一款用于解密web.config配置的工具
ahhacker86的专栏
09-08 850
Sharp4DecryptConnect 是一款专门用于解密使用 DataProtection加密的数据库连接字符串的工具。
【Unity基础】如何选择Mono的.Net API版本
Tealc
09-10 366
本文介绍了如何选择.Net API版本
在VB.net中，如何把"20240906"转化成日期格式
fsyuheduo的博客
09-06 559
==标题==vb.net中，如何把20240906转化成日期格式==正文==在 VB.NET 中，将一个数字字符串（如 "20240906"）转换为日期格式，你可以使用 `DateTime.Parse` 或 `DateTime.TryParse` 方法。这些方法可以将符合日期格式的字符串解析为 `DateTime` 对象。以下是如何将 "20240906" 这样的字符串转换为日期格式的示例：1. ...
Windows .NET8 实现 远程一键部署，几秒完成发布，提高效率 - CICD
天外有天，人外有人。 专注品质 不断创新 让精益求精成为习惯
09-03 767
Windows .NET8 实现 远程一键部署，几秒完成发布，提高效率 - CICD
1、.Net UI框架：Blazor Hybrid - .Net宣传系列文章
lzhdim的专栏
09-07 346
　　 　　Blazor Hybrid 是 .NET 6 中引入的一个新特性，它允许开发者使用 Blazor 技术开发跨平台的桌面和移动应用程序。Blazor Hybrid 结合了 Blazor WebAssembly 和 Blazor Server 的优势，提供了一种在桌面和移动设备上运行 Blazor 应用的方法。 　　Blazor Hybrid 的关键特性包括： 跨平台应用：可以创建在 W...
.Net6/.Net8(.Net Core) IIS中部署 使用 IFormFile 上传大文件报错解决方案
weixin_41934979的博客
09-08 418
最近使用.Net6 WebAPI IFormFile对象接收上传文件时大于30MB(兆)的文件就会报错。1.打开Internet Information Services (llS)管理器，选中主页。上面IIS请求筛选配置完后项目Program中加入以下代码。大约2G,此时上传文件大小在2G内就可以上传成功。4.修改允许的最大内容长度(字节)的值，默认值为。IIS上传文件有大小默认限制大约28.6MB。.无论是Net6还是.Net8写法都一样。web.config示例截图如下。3. 点击编辑功能设置。
.NET 自定义过滤器 - ActionFilterAttribute
黄同学的博客
09-07 1151
是一个自定义的 ASP.NET Core 过滤器，用于在控制器动作执行前验证模型状态，并在模型状态无效时返回一个带有详细错误信息的BadRequest响应。通过使用这个过滤器，可以简化错误处理逻辑，并提高代码的可维护性和可读性。
.NET/C#⾯试题汇总系列：集合、异常、泛型、LINQ、委托、EF！（完整版）
微微的猪食小窝
09-07 962
根据类继承原则和异常处理原则，我们可以使⽤以下⽅式来⾃定义⼀个类：委托（Delegate）是一种类型安全的函数指针，它允许将方法作为参数传递给其他方法，或者将方法作为其他方法的返回值。定义委托类型‌创建委托实例‌调用委托//2、创建委托实例//3、调用委托//1、定义委托类型泛型委托是一种特殊类型的委托，它允许你定义一个委托类型，该类型可以引用任何具有特定签名的方法，而不需要事先知道这些方法的参数类型或返回类型。
使用 .NET 6 构建跨平台 Worker Service 服务：跨越平台的 C# 服务开发——解决Windows服务跨平台问题
martian665的专栏
09-06 1357
使用 .NET 6 构建跨平台 Worker Service 服务：跨越平台的 C# 服务开发——解决Windows服务跨平台问题
C#/.NET/.NET Core推荐学习路线&文档&文章
技术杂谈，聚焦优质文章、开源项目、实用工具和学习、工作、面试心得分享。博客园推荐博客、阿里云专家博主，擅长于C#、.NET、.NET Core、Golang、TypeScript、Vue、Uni App、Angular开发。
09-07 711
专门为C#/.NET/.NET Core推荐学习路线&文档&文章提供的一个Issues，各位小伙伴可以把自己觉得不错的学习路线、文档、文章相关地址分享出来🤞。
在VB.net中，HashSet有什么属性与方法
fsyuheduo的博客
09-05 921
==标题==在VB.net中，HashSet有什么属性与方法==正文==在 VB.NET 中，`HashSet` 是一个集合类，它存储唯一的元素，并且这些元素是无序的。`HashSet` 在 .NET Framework 4 及更高版本中可用，它是 `System.Collections.Generic` 命名空间的一部分。使用HashSet<T>时，最常见的场景包括去重、快速查找...
【.NET全栈】ASP.NET开发Web应用——LINQ技术
JosieBook
09-06 1131
LINQ(Language INtegrated Query)是.NET中的新特性，它提供了统一的语法来查询多种异结构的数据源，开发人员可使用任何.NET语言比如C#或者VB.NET来查询数据源中的数据，而不用管各种异结构数据源之间的差异。LINQ允许开发人员查询任何实现了IEunmerable接口的集合，如Array、List、XML、DOM或者SQL Server数据表。LINQ提供了编译时的类型安全检查和动态类型组合等好处。本章内容有：
购物节抽奖小程序（源码）.zip
最新发布
09-10
购物节抽奖小程序（源码）.zip
COM与.NET互操作性详解
"COM and .NET Interoperability" 在IT领域，COM（Component Object Model）和.NET Framework的交互性是一个重要的主题，它涉及到不同技术之间的兼容性和协同工作能力。COM是微软在90年代推出的一种组件模型，允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值