标签: reflection

请举例说明如何在运行时使用反射在F#中创建新类型(例如,两种类型的笛卡尔积)？

UPDATE

我正在寻找一流的语言.我被告知F#可以这样做.我没有尝试任何东西,因为还没有学习F#.我只想看看它是如何制作的.

假设我有一个Employee班级:

public class Employee
{
    public string Name    { get; set;}
    public string Address { get; set ;
}

现在我想用Employee类'属性名创建一个数组,即:

string[] employeeArray = { "Name", "Address" };

有没有办法在没有硬编码属性名称的情况下实现这一目标？

根据我的理解,应该打印以下代码true,因为两个元素都是equal.

来自java docs,Array.get()将返回:

返回指定数组对象中索引组件的值.如果对象具有基本类型,则该值自动包装在对象中.

但是,当我运行以下代码时,它正在打印 false:

  public class Test1 {

    static boolean equalTest(Object array1, Object array2) {
        return Array.get(array1, 0).equals(Array.get(array2, 0));
    }

    public static void main(String[] args) {
        int[] a = new int[1];
        byte[] b = new byte[1];
        a[0] = 3;
        b[0] = 3;
        System.out.println(equalTest(a, b));
    }
}

我的问题是实现Number的类不是或应该直接相互比较.

您好，我想知道如果 aninterface{}为空，我将如何在 Go 中进行验证。我尝试过reflect.TypeOf(v) == nil，但它总是返回false。

    var h  Bar
    var t  Foo
    pointers := make([]interface{}, 0)
    pointers = append(pointers, &h)
    pointers = append(pointers, &t)

func test(byteValue []byte, data []interface{}) {
    for _, v := range  data {
        fmt.Println(reflect.TypeOf(v) == nil)
        if err := lib.Unmarshal(byteValue, v); err == nil {
            fmt.Println(err)
        }
    }
}

这是一个可以开始的工作示例：

package main

type (
    builder    struct{}
    ISomething interface {
        DoSomething()
    }
    IMyStruct interface {
        MySomething()
    }
    myStruct struct {
        Num       int
        Something ISomething
    }
    Something struct{}
)

func AddSingleton[T any](b *builder, ctor any) {}

func (m *myStruct) MySomething()  {}
func (s *Something) DoSomething() {}

func main() {
    var something ISomething = &Something{}
    b := &builder{}
    for i := 0; i < 2; i++ {
        AddMyStruct(b, something, i)
    }

}
func AddMyStruct(b *builder, something ISomething, num int) {
    AddSingleton[*myStruct](b, func(something …