当前位置：文江博客话题详情

将动态 C# 对象转换为数组

发布于 2024-12-10 19:07:23 字数 158 浏览 0 评论 0原文

如果动态对象是 Foo 或 Foo[] 类型的单个对象，是否有办法将其转换为数组？

例如，

如果动态是 Foo，则转换为数组中包含 1 个对象的 Foo[]

，如果动态是包含 n 个对象的数组 Foo[]，则转换为数组中包含 n 个对象的 Foo[]。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

岁月打碎记忆 2024-12-17 19:07:23

我觉得自己有点傻……这真的是你想要的吗？

class Test
{
}

dynamic dyn = new Test();

Test[] tests = null;

if (dyn is Test)
{
    tests = new Test[] { (Test)dyn };
}
else if (dyn is Test[])
{
    tests = (Test[])dyn;
}

I feel a little stupid... Is really this you want?

class Test
{
}

dynamic dyn = new Test();

Test[] tests = null;

if (dyn is Test)
{
    tests = new Test[] { (Test)dyn };
}
else if (dyn is Test[])
{
    tests = (Test[])dyn;
}

回复收藏 0 原文

无人问我粥可暖 2024-12-17 19:07:23

public Foo[] Create(dynamic fooOrFoos)
{
    return fooOrFoos.GetType().IsArray ? fooOrFoos as Foo[] : new Foo[] { fooOrFoos };
}

也许我让这太简单了......您是否暗示您对动态值可能是什么类型一无所知？

public Foo[] Create(dynamic fooOrFoos)
{
    return fooOrFoos.GetType().IsArray ? fooOrFoos as Foo[] : new Foo[] { fooOrFoos };
}

Perhaps I'm making this too easy... are you implying that you know nothing about what type the dynamic value might be?

回复收藏 0 原文

り繁华旳梦境 2024-12-17 19:07:23

通过使用动态变量，变量是动态的，而不是变量所引用的对象。也就是说，当您想要访问对象的成员或想要转换它时，没有静态类型检查。你需要一些其他的魔法才能做到这一点。

您可以将 Foo 包装在 DynamicObject 中，您可以在其中指定如何进行转换。

public class DynamicWrapper<T> : DynamicObject
{
    public T Instance { get; private set; }
    public DynamicWrapper(T instance)
    {
        this.Instance = instance;
    }

    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.ReturnType == typeof(T))
        {
            result = Instance;
            return true;
        }
        if (binder.ReturnType == typeof(T[]) && binder.Explicit)
        {
            result = new[] { Instance };
            return true;
        }
        return base.TryConvert(binder, out result);
    }

    public override string ToString()
    {
        return Convert.ToString(Instance);
    }
}

然后你可以这样做：

dynamic dobj = new DynamicWrapper<Foo>(someFoo);
Foo foo1 = dobj;
Foo foo2 = (Foo)dobj;
Foo[] arr1 = (Foo[])dobj;
// someFoo == foo1 == foo2 == arr1[0]

dynamic darr = new DynamicWrapper<Foo[]>(arr1);
Foo[] arr2 = darr;
Foo[] arr3 = (Foo[])darr;
// arr1 == arr2 == arr3
// someFoo == arr2[0] == arr3[0]

By using a dynamic variable, the variable is dynamic, not the object the variable is referring to. That is, there is no static type checking when you want to access members of the object or want to convert it. You need some other magic to be able to do that.

You could wrap your Foo in a DynamicObject where you can specify how the conversion takes place.

public class DynamicWrapper<T> : DynamicObject
{
    public T Instance { get; private set; }
    public DynamicWrapper(T instance)
    {
        this.Instance = instance;
    }

    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.ReturnType == typeof(T))
        {
            result = Instance;
            return true;
        }
        if (binder.ReturnType == typeof(T[]) && binder.Explicit)
        {
            result = new[] { Instance };
            return true;
        }
        return base.TryConvert(binder, out result);
    }

    public override string ToString()
    {
        return Convert.ToString(Instance);
    }
}

Then you could do this:

dynamic dobj = new DynamicWrapper<Foo>(someFoo);
Foo foo1 = dobj;
Foo foo2 = (Foo)dobj;
Foo[] arr1 = (Foo[])dobj;
// someFoo == foo1 == foo2 == arr1[0]

dynamic darr = new DynamicWrapper<Foo[]>(arr1);
Foo[] arr2 = darr;
Foo[] arr3 = (Foo[])darr;
// arr1 == arr2 == arr3
// someFoo == arr2[0] == arr3[0]

回复收藏 0 原文

~没有更多了~