本文整理汇总了C#中ISet.Union方法的典型用法代码示例。如果您正苦于以下问题：C# ISet.Union方法的具体用法？C# ISet.Union怎么用？C# ISet.Union使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类ISet的用法示例。
在下文中一共展示了ISet.Union方法的4个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: Union
/// <summary>
/// Performs a "union" of two sets, where all the elements
/// in both are present. That is, the element is included if it is in either <c>a</c> or <c>b</c>.
/// The return value is a <c>Clone()</c> of one of the sets (<c>a</c> if it is not <c>null</c>) with elements of the other set
/// added in. Neither of the input sets is modified by the operation.
/// </summary>
/// <param name="a">The left hand side set of elements to union.</param>
/// <param name="b">The right hand side set of elements to union.</param>
/// <returns>A set containing the union of the input sets. <c>null</c> if both sets are <c>null</c>.</returns>
public static ISet Union(ISet a, ISet b)
{
if (a == null && b == null)
return null;
if (a == null)
return (ISet)b.Clone();
if (b == null)
return (ISet)a.Clone();
return a.Union(b);
}示例2: LayOutSiblingNodes
public static List<Node> LayOutSiblingNodes(ISet<Node> toBeGrouped)
{
if (toBeGrouped.Count <= 1)
return toBeGrouped.ToList();
var groupedNodes = new List<Node>();
var hasBeenAdded = new HashSet<Node>();
var nextGroupTarget = toBeGrouped;
//Remove nodes that does not depend on anything and is never referenced
var unreferenced = toBeGrouped.Where(x => !x.SiblingDependencies.Any()
&& !toBeGrouped.SiblingDependencies().Contains(x)).ToHashSet();
nextGroupTarget.ExceptWith(unreferenced);
while (toBeGrouped.Any())
{
if (!nextGroupTarget.Any())
{
nextGroupTarget = toBeGrouped;
}
while (nextGroupTarget.Any())
{
var currentLayer = GetFacadeNodes(nextGroupTarget);
nextGroupTarget = currentLayer.SiblingDependencies().ToHashSet();
if (nextGroupTarget.Any())
{
//Get the next layer to check if any of the dependencies are unique to a node of the current layer
var nextLayer = GetFacadeNodes(nextGroupTarget);
//Check if any nodes that have not been added yet has dependencies on the unique ones, in this case they arent really unique
var leftForNextBatch = toBeGrouped.Except(currentLayer.Union(nextLayer));
nextLayer.RemoveAll(x => leftForNextBatch.SiblingDependencies().Contains(x));
var uniqueDependencies =
nextLayer.Where(x => !currentLayer.All(n => n.SiblingDependencies.Contains(x)))
.Distinct()
.ToList();
//If there are unique dependencies, vertical layers are created to separate the unique dependency from layers that dont depend on it
if (uniqueDependencies.Any())
{
while (true)
{
//Check if any nodes that have not been added yet has dependencies on the unique ones, in this case they arent really unique
leftForNextBatch = toBeGrouped.Except(currentLayer.Union(nextLayer));
nextLayer.RemoveAll(x => leftForNextBatch.Any(y => y.IndirectlyDependsOn(x)));
var groupsToCreate = FindDependencyPatterns(currentLayer, nextLayer);
var toBeShared = new HashSet<Node>();
toBeGrouped.ExceptWith(currentLayer);
foreach (var dependencyGroup in groupsToCreate)
{
var referencers = dependencyGroup.Referencers;
currentLayer.RemoveRange(referencers.ToList());
var dependants = dependencyGroup.Dependants.ToList();
nextGroupTarget.ExceptWith(dependants);
toBeGrouped.ExceptWith(dependants);
hasBeenAdded.UnionWith(dependants);
hasBeenAdded.UnionWith(referencers);
// Add dependant to the vertical layer
var depNode = CreateHorizontalLayer(dependants);
// Add references to the vertical layer
var referenceNode = CreateHorizontalLayer(referencers);
var newList = new List<Node> {depNode, referenceNode};
//Get ALL the possible candidates for the vertical layer
var verticalCandidates =
referencers.SelectMany(x => x.IndirectSiblingDependencies())
.Except(dependants)
.Union(
dependants.SelectMany(x => x.IndirectSiblingDependencies()))
.Distinct()
.Except(hasBeenAdded).Intersect(toBeGrouped)
.ToHashSet();
//Get all the nodes in this current call depth
var otherGroups = groupsToCreate.Except(dependencyGroup);
var nodesInOtherGroups = otherGroups.
SelectMany(x => x.Dependants.Union(x.Referencers)).ToHashSet();
var otherNodes =
toBeGrouped.Union(currentLayer)
.Union(nodesInOtherGroups)
.Except(verticalCandidates)
.ToHashSet();
var siblingDepsRelevantForNewNode = new HashSet<Node>();
//If any of the other nodes depends on the vertical candidate the candidate is removed and will be placed in a later iteration of this call (it is still left in toBeGrouped)
foreach (var candidate in verticalCandidates.ToList())
{
var otherNodesDependantOnCandidate =
otherNodes.Where(x => x.IndirectlyDependsOn(candidate)).ToHashSet();
if (toBeShared.Contains(candidate) || otherNodesDependantOnCandidate.Any())
{
verticalCandidates.Remove(candidate);
toBeShared.Add(candidate);
}
}
if (verticalCandidates.Any())
{
toBeGrouped.ExceptWith(verticalCandidates);
nextGroupTarget.ExceptWith(verticalCandidates);
hasBeenAdded.UnionWith(verticalCandidates);
//.........这里部分代码省略.........
示例3: Union
/// <summary>
/// Performs a "union" of two sets, where all the elements in both are
/// present.
/// </summary>
/// <remarks>
/// <p>
/// That is, the element is included if it is in either
/// <paramref name="setOne"/> or <paramref name="anotherSet"/>. The return
/// value is a <b>clone</b> of one of the sets (<paramref name="setOne"/>
/// if it is not <see langword="null"/>) with elements of the other set
/// added in. Neither of the input sets is modified by the operation.
/// </p>
/// </remarks>
/// <param name="setOne">A set of elements.</param>
/// <param name="anotherSet">A set of elements.</param>
/// <returns>
/// A set containing the union of the input sets;
/// <see langword="null"/> if both sets are <see langword="null"/>.
/// </returns>
public static ISet Union(ISet setOne, ISet anotherSet)
{
if (setOne == null && anotherSet == null)
{
return null;
}
else if (setOne == null)
{
return (ISet) anotherSet.Clone();
}
else if (anotherSet == null)
{
return (ISet) setOne.Clone();
}
else
{
return setOne.Union(anotherSet);
}
}示例4: Union
public static ISet Union(ISet s1, ISet s2)
{
return s1.Union(s2);
}