Extension methods are a concise way of binding functions to particular types.
In my last post, I showed how Extension methods can be created in the .NET 2.0 environment.
In this post, I discuss calling the extensions from other languages.
Most of the differences I find between the Dot Net languages are mainly syntax. The declaration of Extensions is no exception. There is, however, a distinct difference with the framework accepting excensions made with C++ that differs from C# and VB.
When calling the C++ extension from C#, the compiler will SOMETIMES say there is no definition for DoCPP with the error:
'string' does not contain a definition for 'DoCPP' and no extension method 'DoCPP' accepting a first argument of type 'string' could be found (are you missing a using directive or an assembly reference?)
If I recompile, the error goes away.
The strangest problem with calling the C++ extension from C# is that I first must make SOME type of reference to the class BEFORE using the extension or it will not be recognized at all. So, if I first call the DoCPP() as a static method, the extension works fine later. If I make a dummy instantiation of the class, it works. If I have no forward reference of the class, I get the same error as before and recompiling does not fix it. It seems as if this none of this is supposed to work across the languages.
I have made a few work-arounds to get the examples to compile and run.
Note the following examples:
Extension in C#
using System;
namespace Extension_CS
{
public static class CExtension_CS
{ //in C#, the "this" keyword is the key.
public static void DoCS(this string str)
{
Console.WriteLine("CS\t{0:G}\tCS", str);
}
}
}
Extension in C++
/****************************************************************************\
* Here is the C++ implementation. It is the least elegant and most quirky,
* but it works.
\****************************************************************************/
#pragma once
using namespace System;
using namespace System::Runtime::CompilerServices; //<-Essential
// Reference: System.Core.dll //<- Essential
namespace Extension_CPP {
public ref class CExtension_CPP
{
public:
[Extension] // or [ExtensionAttribute] /* either works */
static void DoCPP(String^ str)
{
Console::WriteLine("C++\t{0:G}\tC++", str);
}
};
}
Extension in VB
' Here is the VB implementation. This is not as elegant as the C#, but it's
' functional.
Imports System.Runtime.CompilerServices
'
Public Module modExtension_VB 'Extension methods can be defined only in modules.
<Extension()> _
Public Sub DoVB(ByVal str As String)
Console.WriteLine("VB" & Chr(9) & "{0:G}" & Chr(9) & "VB", str)
End Sub
End Module
Calling program in C#
/******************************************************************************\
* Main calling program
* Intellisense and VS2008 complain about the CPP implementation, but with a
* little duct-tape, it works just fine.
\******************************************************************************/
using System;
using Extension_CPP;
using Extension_CS;
using Extension_VB; // vitual namespace
namespace TestExtensions
{
public static class CTestExtensions
{
/**********************************************************************\
* For some reason, this needs a direct reference into the C++ version
* even though it does nothing than add a null reference.
* The constructor provides the fake usage to please the compiler.
\**********************************************************************/
private static CExtension_CPP x = null; // <-DUCT_TAPE!
static CTestExtensions()
{
// Fake usage to stop compiler from complaining
if (null != x) {} // <-DUCT_TAPE
}
static void Main(string[] args)
{
string strData = "from C#";
strData.DoCPP();
strData.DoCS();
strData.DoVB();
}
}
}
Calling program in VB
Imports Extension_CPP
Imports Extension_CS
Imports Extension_VB
Imports System.Runtime.CompilerServices
Module TestExtensions_VB
<Extension()> _
Public Sub DoCPP(ByVal str As String)
'Framework does not treat this as an extension, so use the static
CExtension_CPP.DoCPP(str)
End Sub
Sub Main()
Dim strData As String = "from VB"
strData.DoCS()
strData.DoVB()
strData.DoCPP() 'fake
End Sub
End Module
Calling program in C++
// TestExtensions_CPP.cpp : main project file.
#include "stdafx.h"
using namespace System;
using namespace Extension_CPP;
using namespace Extension_CS;
using namespace Extension_VB;
void main(void)
{
/*******************************************************\
* Extension methods are called like static methods
* when called from C++. There may be a difference in
* syntax when calling the VB extension as VB Extensions
* are embedded in Modules instead of classes
\*******************************************************/
String^ strData = "from C++";
CExtension_CPP::DoCPP(strData);
CExtension_CS::DoCS(strData);
modExtension_VB::DoVB(strData); //since Extensions go in Modules
}
