需要一个在VB.NET中使用的C＃类的工作示例

Question

谁能给我一个简短的C＃类工作示例，该示例可以编译为DLL，还有一个VB.NET代码示例，该示例基于此类并使用其成员（方法）创建对象。 C＃类必须具有一个名称空间，至少一个类定义（显然）和一些方法或应调用的任何方法。 我有别人的C＃-DLL代码，但是在我的VB项目中看不到它的成员。 我知道我必须在我的VB.NET项目中引用DLL。 我正在使用VB.NET Express 2008和C＃2008 Express。

Answer 1

--foo.cs

namespace Sharp
{
    public class Foo
    {
        public string Message
        {
            get { return "This is from CSharp"; }
        }
    }
}

--bar.vb

Namespace bartest
   Public Class Bar

     Public Shared Sub Main()
        Dim test as Sharp.Foo
        test = New Sharp.Foo()
        Console.WriteLine(test.Message)

     End Sub

  End Class
End Namespace

--batch文件进行编译

%WINDIR%\Microsoft.NET\Framework\v3.5\csc.exe /target:library foo.cs 
%WINDIR%\Microsoft.NET\Framework\v3.5\vbc.exe bar.vb /reference:foo.dll

-运行bar.exe

Answer 2

托管程序集（DLL和EXE）不是“ C＃”或“ VB.NET”或任何其他语言。

它们是带有CIL的 .NET程序集，应与任何.NET语言互操作。

一旦在项目中引用了这样的程序集，就可以访问其中的所有公共类型。

如果看不到任何成员，请确保将它们确实声明为public ，因为大多数成员的C＃默认为internal成员或private成员。

在此处阅读有关C＃中的访问修饰符的更多信息。

Answer 3

我的猜测是，您尝试访问的成员只是未声明为public因此无法跨名称空间使用它们。

如果您想要一个可行的示例，只需创建一个新的解决方案，然后按照以下步骤操作。

1. 添加一个VB.net代码项目
2. 添加公共课程。
3. 添加一个C＃代码项目。
4. 添加一个简单的C＃类。

进行此设置后，只需在一个项目中引用另一个项目，然后尝试在创建的类之一中调用它即可。

您可以使用任何.Net dll进行此操作，只要成员被声明为public或名称空间相同且成员被声明为internal 。

Answer 4

这是一个有效的示例-我必须在C＃代码中重命名一些ComputeFingerprint重载，以使VB.Net正确识别要调用的特定对象。 也许这些是您无法解决的上述错误？

C＃代码：

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 ComputeFingerPrint2(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 ComputeFingerPrint3(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 ComputeFingerPrint4(byte[] source)
        {
            return ComputeFingerPrint3(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]);
        }
    }
}

VB.Net代码（已测试，结果= 8533825001260623604）：

Imports RF

Module Module1

    Sub Main()

        Dim input = "this is the string"
        Dim result = RF.RabinFingerprint.ComputeFingerprint(input)

    End Sub

End Module

Answer 5

像C＃到VB转换器那样的东西可以工作吗？ 如果您有代码，并且对VB感到满意，请在VB中工作。

该博客提供了一个在步骤2中将C＃用作类库的示例以及一个示例应用程序。