blocks|key|346559|text|答案之一是使用反应性扩展(Rx)。您可以从NuGet获得它，它是由微软开发的。在它的帮助下，您可以简单地说：myListCollection.ToObservable();|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|346560|如果您的子集合始终位于同名节点中，则可以使用while(item.Collection+!=+null+%7C%7C+item.Collection.Count+==+0)并将ToObservable()放在循环中。|346561|entityMap^0|1I|W|0|M|1O|2C|E|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

One part of the answer is to use Reactive Extensions (Rx). You can get it from NuGet and it's developed by Microsoft. With the help of it you can simply say: <code>myListCollection.ToObservable();</code>

If your child collections always are in a node with the same name you could use a <code>while(item.Collection != null || item.Collection.Count == 0)</code> and put the <code>ToObservable()</code> within the loop

blocks|key|228047|text|假设您指的是ObservableCollection<T>，如果您希望List直接按原样传递给ObservableCollection，只需使用构造函数：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|228048|var+oc+=+new+ObservableCollection<Object>(yourListOfObject);|code-block|syntax|javascript|228049|现在，如果您想要解压其中的每一个，您需要做一些工作来将它们折叠到一个ObservableCollection<T>中。|228050|entityMap^0|6|N|Z|4|1B|K|0|0|Y|N|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

Assuming you mean <code>ObservableCollection&lt;T&gt;</code>, if you wanted the <code>List</code> directly to the <code>ObservableCollection</code> as-is, just use the constructor:

<pre><code>var oc = new ObservableCollection&lt;Object&gt;(yourListOfObject);
</code></pre>

Now, if you're wanting to unwind each of those, you would need to do some work to collapse them into a single <code>ObservableCollection&lt;T&gt;</code>.

blocks|key|345635|text|假设您有一个定义如下的节点类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|345636|public+class+Node
{
++++public+ICollection<Node>+Children+{+get;+set;+}
}|code-block|syntax|javascript|345637|您可以在任何深度使用递归来转换List<Node>集合：|offset|length|style|CODE|345638|public+static+ObservableCollection<Node>+ToObservableRecursive(ICollection<Node>+nodes)
{
++++foreach+(Node+node+in+nodes)
++++++++if+(node.Children+!=+null)
++++++++++++node.Children+=+ToObservableRecursive(node.Children);

++++return+new+ObservableCollection<Node>(nodes);
}|345639|entityMap^0|0|0|F|A|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Assuming you have a node class defined like so:

<pre><code>public class Node
{
 public ICollection&lt;Node&gt; Children { get; set; }
}
</code></pre>

You can use recursion to convert <code>List&lt;Node&gt;</code> collections, at any level of depth:

<pre><code>public static ObservableCollection&lt;Node&gt; ToObservableRecursive(ICollection&lt;Node&gt; nodes)
{
 foreach (Node node in nodes)
 if (node.Children != null)
 node.Children = ToObservableRecursive(node.Children);

 return new ObservableCollection&lt;Node&gt;(nodes);
}
</code></pre>

blocks|key|708545|text|我猜你是在说ObservableCollection。简单地回答，您可以使用ctor：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|708546|List<Object>+myList+=+GetList();
new+ObservableCollection<Object>(myList);|code-block|syntax|javascript|708547|但是，我认为在按层次组织您的信息方面还有一些工作要做。|708548|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I assume you're talking about ObservableCollection. To answer simply, you can use the ctor:

<pre><code>List&lt;Object&gt; myList = GetList();
new ObservableCollection&lt;Object&gt;(myList);
</code></pre>

However, I think there is some work left to be done in terms of organizing your information hierarchically.

blocks|key|708565|text|你是说ObservableCollection吗？如果您希望子级Lists也是可观察的，那么您将需要遍历树并根据需要更改项，或者首先分别添加每个项。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|708566|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/ms668604.aspx^0|W|5|3|K|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Do you mean <a href="http://msdn.microsoft.com/en-us/library/ms668604.aspx" rel="nofollow">ObservableCollection</a>? If you want the child level <code>Lists</code> to be observable also then you will need to traverse the tree and change items as necessary or add each item separately to begin with.

blocks|key|346598|text|在您的类型相同之前，您不能执行这里列出的任何解决方案！例如，如果您的列表或ICollection或IEnumerable的类型是string，但是您的ObservableCollection需要类型为Nodes或Computers或其他什么，那么首先您必须将列表放入该类型！我浪费了那么多时间在其他虚假的、简化的“解决方案”上，它们不是解决方案，因为它们没有解释这一点，也没有考虑到这个因素。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|346599|说这是你的ObservableCollection|346600|public+class+Computer
{
++++public+string+Name+{+get;+set;+}
}|code-block|syntax|javascript|346601|很标准，对吧？在许多项目中，您可能最终会用任意数量的东西替换Computer。|346602|如果然后在List<string>中获得一个名为lstComputers的计算机名称列表，则不能仅使用以下方法转换该列表：|346603|var+oc+=+new+ObservableCollection<Computer>(lstComputers);|346604|它会说您的类型不匹配，不能从一种转换到另一种，因为您试图将List<string>插入到ObservableCollection<Computer>中。方形钉在圆孔里。|346605|相反，在获取计算机名称的函数中，必须添加所有“特殊类”：|346606|public+static+List<Computer>+NetworkComputers()
{
++++List<Computer>+lstComputers+=+new+List<Computer>();
++++DirectoryEntry+root+=+new+DirectoryEntry("WinNT:");
++++foreach+(DirectoryEntry+computers+in+root.Children)
++++{
++++++++foreach+(DirectoryEntry+computer+in+computers.Children)
++++++++{
++++++++++++if+(computer.Name+!=+"Schema"+&&+computer.SchemaClassName+==+"Computer")
++++++++++++{
++++++++++++++++lstComputers.Add(new+Computer()+{+Name+=+computer.Name+});
++++++++++++}
++++++++}
++++}+
}|346607|仅仅因为我们使用了行lstComputers.Add(new+Computer()+{+Name+=+computer.Name+});，并且返回的是List<Computer>而不是List<string>，所以我们现在才能将它放入ObservableCollection<Computer>中。|346608|如果您错过了这条船，并且从一开始就不能这样做，那么这个线程将讨论其他您可能完成转换的方法：使用lambda表达式将对象列表从一种类型转换为另一种类型。|346609|因此，一旦您在List<Computer>中获得了它，只有这样您才能做到：|346610|List<Computer>+lstComputers+=+NetworkComputers();
var+oc+=+new+ObservableCollection<Computer>(lstComputers);|346611|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1909268/convert-a-list-of-objects-from-one-type-to-another-using-lambda-expression^0|1S|6|23|K|2S|5|2Y|9|0|5|K|0|0|U|8|0|5|C|O|C|0|0|T|C|18|U|0|0|0|A|1M|23|E|2K|C|39|U|0|19|U|0|0|7|E|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1Q|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|J|7|1Z|8|@]|D|@]|E|$K|L]]|$1|S|3|T|5|6|7|20|8|@$9|21|A|22|B|C]|$9|23|A|24|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|25|8|@]|D|@]|E|$]]|$1|W|3|X|5|J|7|26|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|27|8|@$9|28|A|29|B|C]|$9|2A|A|2B|B|C]|$9|2C|A|2D|B|C]|$9|2E|A|2F|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|2G|8|@]|D|@$9|2H|A|2I|1|2J]]|E|$]]|$1|12|3|13|5|6|7|2K|8|@$9|2L|A|2M|B|C]]|D|@]|E|$]]|$1|14|3|15|5|J|7|2N|8|@]|D|@]|E|$K|L]]|$1|16|3|-4|5|6|7|2O|8|@]|D|@]|E|$]]]|17|$18|$5|19|1A|1B|E|$1C|1D]]]]

You cannot do any of the solutions listed here until your types are the same! If your list or ICollection or IEnumerable is of type <code>string</code>, for example, but your <code>ObservableCollection</code> needs to be of type <code>Nodes</code> or <code>Computers</code> or something else, you have to get the List into that type, first! I wasted so much time on these other bogus, simplified "solutions" that are NOT solutions because they do not explain this or take this factor into account.

Say this is your <code>ObservableCollection</code>:

<pre><code>public class Computer
{
 public string Name { get; set; }
}
</code></pre>

Pretty standard, right? You'd probably end up replacing <code>Computer</code> with any number of things in any number of projects.

If you then get a list of computer names in a <code>List&lt;string&gt;</code> called <code>lstComputers</code>, you CANNOT just convert that using:

<pre><code>var oc = new ObservableCollection&lt;Computer&gt;(lstComputers);
</code></pre>

It will say your types are mismatched and cannot be converted from one to the other because you are trying to shove a <code>List&lt;string&gt;</code> into an <code>ObservableCollection&lt;Computer&gt;</code>. Square peg in a round hole.

Instead, in your function for getting the computer names, you have to add them all "special-like":

<pre><code>public static List&lt;Computer&gt; NetworkComputers()
{
 List&lt;Computer&gt; lstComputers = new List&lt;Computer&gt;();
 DirectoryEntry root = new DirectoryEntry("WinNT:");
 foreach (DirectoryEntry computers in root.Children)
 {
 foreach (DirectoryEntry computer in computers.Children)
 {
 if (computer.Name != "Schema" &amp;&amp; computer.SchemaClassName == "Computer")
 {
 lstComputers.Add(new Computer() { Name = computer.Name });
 }
 }
 } 
}
</code></pre>

Only because we used that line <code>lstComputers.Add(new Computer() { Name = computer.Name });</code> and are returning the <code>List&lt;Computer&gt;</code> and not <code>List&lt;string&gt;</code> can we now put it into our <code>ObservableCollection&lt;Computer&gt;</code>.

If you missed the boat and can't do it like this from the start, this thread talks about other ways you might be able to do your conversion:
<a href="https://stackoverflow.com/questions/1909268/convert-a-list-of-objects-from-one-type-to-another-using-lambda-expression">convert a list of objects from one type to another using lambda expression</a>

So once you have it in a <code>List&lt;Computer&gt;</code>, only then you can do:

<pre><code>List&lt;Computer&gt; lstComputers = NetworkComputers();
var oc = new ObservableCollection&lt;Computer&gt;(lstComputers);
</code></pre>

I have got <code>List&lt;Object&gt;</code> where the Object has a lot of childs <code>List&lt;Object&gt;</code> around 4-6 levels.

Now I have to bind it to WPF TreeView... :(

Which the best way to convert it into <code>ObservableCollection&lt;Object&gt;</code> is?

The best way to convert List<Object> to ObservableCollection<Object>

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我得到了List<Object>，对象在4-6级之间有大量的childs List<Object>。现在我得把它绑定到WPF TreeView..。:(哪一种是将其转换为ObservableCollection<Object>的最佳方式？

问将List<Object>转换为ObservableCollection<Object>的最佳方法
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将List<Object>转换为ObservableCollection<Object>的最佳方法EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问将List<Object>转换为ObservableCollection<Object>的最佳方法
EN