如何从VB.Net调用C＃类的静态方法？ [英] How to call a C# class's static method from VB.Net?
本文介绍了如何从VB.Net调用C＃类的静态方法？的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
我的C＃dll代码：
使用系统;
使用System.Collections.Generic;
使用System.Linq;
使用System.Text;
命名空间RF
{
///< summary>
///Génèredes empreintes de fichiers
///< / summary>
public static class RabinFingerprint
{
///< summary>
///多项式P的位64始终为1，不被直接处理。这是多项式
///，导数系数被去除（lcr）。
///表示t ^ 64 + t ^ 4 + t ^ 3 + t + 1
///< / summary>
private static readonly UInt64 p_lcr = 0x000000000000001BL;
///< summary>
///只要不使用
///地址，就不必为这样的整型常量变量提供定义。
///多项式P.的度数
///< / summary>
private static readonly int K = 64;
///< summary>
///表示t ^（K-1）
///< / summary>
private static readonly UInt64 T_K_minus_1 =（UInt64）1L < （K-1）;
///< summary>
/// Broder的论文提出了四个预先计算的表，因为单词被认为是32位。
///在这个实现中，W是一个64位整数类型。使用八个表。
///表A是i1 ^ 127 + i2 ^ 126 + ... + i8 ^ 120。
///表B是i1 ^ 119 + i2 ^ 118 + ... + i8 ^ 112。
///表C，D，..
///表E是i1 ^ 95 + i2 ^ 94 + ... + i8 ^ 88。 （这是本文中的表A）
///表F，G，H.
///< / summary>
private static UInt64 [] tableA_ = new UInt64 [256]; //假设字节大小8.
private static UInt64 [] tableB_ = new UInt64 [256];
private static UInt64 [] tableC_ = new UInt64 [256];
private static UInt64 [] tableD_ = new UInt64 [256];
private static UInt64 [] tableE_ = new UInt64 [256];
private static UInt64 [] tableF_ = new UInt64 [256];
private static UInt64 [] tableG_ = new UInt64 [256];
private static UInt64 [] tableH_ = new UInt64 [256];
///< summary>
///构造函数
///< / summary>
static RabinFingerprint（）
{
InitTables（）;
}
///< summary>
///初始化表
///< / summary>
private static void InitTables（）
{
//这表示t ^（k + i）mod P，其中i是数组的索引。
//将用于计算表。
UInt64 [] mods = new UInt64 [K];
//记住t ^ k mod P等价于p_lcr。
mods [0] = p_lcr; （int i = 1; i< K; ++ i）
{
//通过属性：t ^ i mod P = t（t ^（i-1）） mod P.
mods [i] = mods [i-1]<< 1;
//如果mods [i-1]在k-1处有一个项，则mods [i]将具有未被表示的项k。
//这个术语k将再次被P除以P.然后，效果与将p_lcr添加到mod相同的
//。
if（（mods [i-1]& T_K_minus_1）！= 0）
mods [i] ^ = p_lcr;
}
//计算表。控制变量用于指示当前位是否应为
//。 （int i = 0; i <256; ++ i）
{
int control = i;
for（int j = 0; j&&& control> 0; ++ j）
{
// bool.Parse（Convert.ToString（））
if（（control& 1）== 1）//好的，考虑一下。 （（byte））
{
tableA_ [i] ^ = mods [j + 56];
tableB_ [i] ^ = mods [j + 48];
tableC_ [i] ^ = mods [j + 40];
tableD_ [i] ^ = mods [j + 32];
tableE_ [i] ^ = mods [j + 24];
tableF_ [i] ^ = mods [j + 16];
tableG_ [i] ^ = mods [j + 8];
tableH_ [i] ^ = mods [j];
}
control>> = 1;
}
}
}
///< summary>
/// Compute hash key
///< / summary>
///< param name =value>要进行散列的值< / param>
///< returns> Value< / returns>
private static UInt64 ComputeTablesSum（ref UInt64 value）
{
value = tableH _ [（（value）& 0xFF）] ^
tableG _ [（（value>> 8 ）&$ 0xFF）] ^
tableF _ [（（value>>> 16）& 0xFF）] ^
tableE _ [（（value>> 24）& 0xFF）] ^
tableD _ [（（value>>> 32）& 0xFF）] ^
tableC _ [（（value>> 40）& 0xFF）] ^
tableB _ [（（value > 48）& 0xFF）] ^
tableA _ [（（value> gt; 56）& 0xFF）];
返回值; //通过引用返回相同的w。 （便利和效率）
}
///< summary>
/// Compute hask hey
///< / summary>
///< param name =HashArray> Ulong数组到ahsh< / param>
///< returns>哈希键< / returns>
private static UInt64 Compute（UInt64 [] HashArray）
{
UInt64 w = 0L;
for（int s = 0; s< HashArray.Length; ++ s）
w = ComputeTablesSum（ref w）^ HashArray [s];
return w;
}
///< summary>
///计算指纹
///< / summary>
///< param name =source>要计算的字符串< / param>
///< returns>哈希键< / returns>
public static UInt64 ComputeFingerPrint（string source）
{
byte [] table = Encoding.Unicode.GetBytes（source）;
UInt64 [] values = new UInt64 [table.LongLength];
ConvertBytes（ref表，ref值）;
return Compute（values）;
}
///< summary>
///计算指纹，必须使用这种方法来获取非常大的文本
///< / summary>
///< param name =source>要计算的字符串< / param>
///< returns>哈希键< / returns>
public static UInt64 ComputeFingerPrint（ref string source）
{
return ComputeFingerPrint（source）;
}
///< summary>
///计算指纹，必须使用这种方法来获取非常大的二进制数据
///< / summary>
///< param name =source>要计算的数据< / param>
///< returns>散列键< / returns>
public static UInt64 ComputeFingerPrint（ref byte [] source）
{
UInt64 [] values = new UInt64 [source.LongLength];
ConvertBytes（ref source，ref values）;
return Compute（values）;
}
///< summary>
///计算指纹，必须使用这种方法来获取非常大的二进制数据
///< / summary>
///< param name =source>要计算的数据< / param>
///< returns>哈希键< / returns>
public static UInt64 ComputeFingerPrint（byte [] source）
{
return ComputeFingerPrint（ref source）;
}
///< summary>
///将字节数组计算到Uint64数组
///< / summary>
///< param name =source>表de字节源< / param>
///< param name =destination> Tableau de Uin64< / param>
private static void ConvertBytes（ref byte [] source，ref UInt64 [] destination）
{
for（long i = 0; i< source.LongLength; i ++）
destination [i] = Convert.ToUInt64（source [i]）;
}
}
}
我的VB代码： p>
导入RF
模块Module1
Sub Main（）
Dim t As New RabinFingerprint
End Sub
结束模块
解决方案
如果要使用实例，则需要向C＃类添加一个非静态构造函数 - 目前只有一个静态构造函数。 >
有关于VB.Net和C＃中静态/共享之间差异的信息这里，这可能对解决这个有用。
如果你在C＃中这样做，你只需调用类的静态方法，如
UInt64 result = RabinFingerprint.ComputeFIngerprint（...）;
等。
在VB.Net中，这看起来像这样：
Dim result = RF.RabinFingerprint.ComputeFingerprint（...）
这里是我的意思是 MSDN 示例。这两个 Console.WriteLine 和 Regex.Split 是静态的，就像你的类的方法一样。
Dim input As String =plum-pear
Dim pattern As String = - 'Split在连字符上
Dim substrings（）As String = Regex.Split（input，pattern）
对于每个匹配As String在子串中
Console.WriteLine（'{0}' ，match）
Next
'该方法将以下内容写入控制台：
''plum'
'''
''pear'
I have a C# dll and want to use it in VB.NET. I'm using C# 2008 Express and VB 2008 Express. I have added a reference in a VB project to the C# dll. When I create an instane of a class in the C# dll, it gives the following error messsage: "Type 'RF.RabinFingerprint' has no constructors". How do I fix this?
My C# dll code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace RF
{
/// <summary>
/// Génère des empreintes de fichiers
/// </summary>
public static class RabinFingerprint
{
/// <summary>
/// Bit 64 of the polynomial P is always 1 and not treated directly. This is the polynomial
/// with the leading coefficient removed (lcr).
/// Represents t^64 + t^4 + t^3 + t + 1.
/// </summary>
private static readonly UInt64 p_lcr = 0x000000000000001BL;
/// <summary>
/// It's not necessary to provide definitions for such integral constant variables as long as their
/// addresses are not taken.
/// Degree of the polynomial P.
/// </summary>
private static readonly int K = 64;
/// <summary>
/// Represents t^(K-1)
/// </summary>
private static readonly UInt64 T_K_minus_1 = (UInt64)1L << (K - 1);
/// <summary>
/// Broder's paper presents four pre-computed tables because words are considered to be 32-bit.
/// In this implementation W is a 64-bit integral type. Eight tables are used.
/// Table A is i1^127 + i2^126 + ... + i8^120.
/// Table B is i1^119 + i2^118 + ... + i8^112.
/// Table C, D, ..
/// Table E is i1^95 + i2^94 + ... + i8^88. (This is table A in the paper.)
/// Table F, G, H.
/// </summary>
private static UInt64[] tableA_ = new UInt64[256]; //Assuming byte size 8.
private static UInt64[] tableB_ = new UInt64[256];
private static UInt64[] tableC_ = new UInt64[256];
private static UInt64[] tableD_ = new UInt64[256];
private static UInt64[] tableE_ = new UInt64[256];
private static UInt64[] tableF_ = new UInt64[256];
private static UInt64[] tableG_ = new UInt64[256];
private static UInt64[] tableH_ = new UInt64[256];
/// <summary>
/// Constructor
/// </summary>
static RabinFingerprint()
{
InitTables();
}
/// <summary>
/// Initialize tables
/// </summary>
private static void InitTables()
{
//This represents t^(k + i) mod P, where i is the index of the array.
//It will be used to compute the tables.
UInt64[] mods = new UInt64[K];
//Remember t^k mod P is equivalent to p_lcr.
mods[0] = p_lcr;
for (int i = 1; i < K; ++i)
{
//By property: t^i mod P = t(t^(i - 1)) mod P.
mods[i] = mods[i - 1] << 1;
//If mods[i - 1] had a term at k-1, mods[i] would have had the term k, which is not represented.
//The term k would account for exactly one more division by P. Then, the effect is the same
//as adding p_lcr to the mod.
if ((mods[i - 1] & T_K_minus_1) != 0)
mods[i] ^= p_lcr;
}
//Compute tables. A control variable is used to indicate whether the current bit should be
//considered.
for (int i = 0; i < 256; ++i)
{
int control = i;
for (int j = 0; j < 8 && control > 0; ++j)
{
// bool.Parse(Convert.ToString())
if ((control & 1) == 1) //Ok, consider bit. ((byte))
{
tableA_[i] ^= mods[j + 56];
tableB_[i] ^= mods[j + 48];
tableC_[i] ^= mods[j + 40];
tableD_[i] ^= mods[j + 32];
tableE_[i] ^= mods[j + 24];
tableF_[i] ^= mods[j + 16];
tableG_[i] ^= mods[j + 8];
tableH_[i] ^= mods[j];
}
control >>= 1;
}
}
}
/// <summary>
/// Compute hash key
/// </summary>
/// <param name="value">Value to hash</param>
/// <returns>Value</returns>
private static UInt64 ComputeTablesSum(ref UInt64 value)
{
value = tableH_[((value) & 0xFF)] ^
tableG_[((value >> 8) & 0xFF)] ^
tableF_[((value >> 16) & 0xFF)] ^
tableE_[((value >> 24) & 0xFF)] ^
tableD_[((value >> 32) & 0xFF)] ^
tableC_[((value >> 40) & 0xFF)] ^
tableB_[((value >> 48) & 0xFF)] ^
tableA_[((value >> 56) & 0xFF)];
return value; //Pass by reference to return the same w. (Convenience and efficiency.)
}
/// <summary>
/// Compute hask hey
/// </summary>
/// <param name="HashArray">Array of Ulong bytes to ahsh</param>
/// <returns>Hash key</returns>
private static UInt64 Compute(UInt64[] HashArray)
{
UInt64 w = 0L;
for (int s = 0; s < HashArray.Length; ++s)
w = ComputeTablesSum(ref w) ^ HashArray[s];
return w;
}
/// <summary>
/// Compute the fingerprint
/// </summary>
/// <param name="source">String to compute</param>
/// <returns>Hash key</returns>
public static UInt64 ComputeFingerPrint(string source)
{
byte[] table = Encoding.Unicode.GetBytes(source);
UInt64[] values = new UInt64[table.LongLength];
ConvertBytes(ref table, ref values);
return Compute(values);
}
/// <summary>
/// Compute the fingerprint, you must use this method for very large text
/// </summary>
/// <param name="source">String to compute</param>
/// <returns>Hash key</returns>
public static UInt64 ComputeFingerPrint(ref string source)
{
return ComputeFingerPrint(source);
}
/// <summary>
/// Compute the fingerprint, you must use this method for very large binary data
/// </summary>
/// <param name="source">Data to compute</param>
/// <returns>Hash key</returns>
public static UInt64 ComputeFingerPrint(ref byte[] source)
{
UInt64[] values = new UInt64[source.LongLength];
ConvertBytes(ref source, ref values);
return Compute(values);
}
/// <summary>
/// Compute the fingerprint, you must use this method for very large binary data
/// </summary>
/// <param name="source">Data to compute</param>
/// <returns>Hash key</returns>
public static UInt64 ComputeFingerPrint(byte[] source)
{
return ComputeFingerPrint(ref source);
}
/// <summary>
/// Compute byte array to Uint64 array
/// </summary>
/// <param name="source">Table de byte source</param>
/// <param name="destination">Tableau de Uin64</param>
private static void ConvertBytes(ref byte[] source, ref UInt64[] destination)
{
for (long i = 0; i < source.LongLength; i++)
destination[i] = Convert.ToUInt64(source[i]);
}
}
}
My VB code:
Imports RF
Module Module1
Sub Main()
Dim t As New RabinFingerprint
End Sub
End Module
解决方案
If you want to use instances, you need to add a non-static constructor to the C# class - currently it's only got a static constructor.
There is info on diffs between static/shared in VB.Net and C# here that could be useful in resolving this.
If you were doing this in C# you just call the class's static methods like
UInt64 result = RabinFingerprint.ComputeFIngerprint(...);
etc.
In VB.Net this looks something like this:
Dim result = RF.RabinFingerprint.ComputeFingerprint(...)
Here is an example from MSDN of what I mean. Here both Console.WriteLine and Regex.Split are static, just like your class's methods.
Dim input As String = "plum--pear"
Dim pattern As String = "-" ' Split on hyphens
Dim substrings() As String = Regex.Split(input, pattern)
For Each match As String In substrings
Console.WriteLine("'{0}'", match)
Next
' The method writes the following to the console:
' 'plum'
' ''
' 'pear'
这篇关于如何从VB.Net调用C＃类的静态方法？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
