IDisposable IHandlersManager.AddLink(string fromMethod, string toMethod)
{
var source = _descriptors.FirstOrDefault(z => z.Method == fromMethod);
if (source == null)
{
if (_descriptors.Any(z => z.Method == toMethod))
{
throw new ArgumentException(
$"Could not find descriptor for '{fromMethod}', but I did find one for '{toMethod}'. Did you mean to link '{toMethod}' to '{fromMethod}' instead?", fromMethod
);
}
throw new ArgumentException(
$"Could not find descriptor for '{fromMethod}', has it been registered yet? Descriptors must be registered before links can be created!", nameof(fromMethod)
);
}
HandlerDescriptor descriptor = null;
descriptor = GetDescriptor(
toMethod,
source.HandlerType,
source.Handler,
source.RequestProcessType.HasValue ? new JsonRpcHandlerOptions {
RequestProcessType = source.RequestProcessType.Value
} : null,
source.TypeDescriptor,
source.HandlerType
);
Interlocked.Exchange(ref _descriptors, _descriptors.Add(descriptor));
return(descriptor);
}
private static void UpdateProduct(ImmutableHashSet <ParsedProduct> toUpdateParsedProducts, Product productToUpdate)
{
var parsedProduct = toUpdateParsedProducts.FirstOrDefault(u => ProductDataComparer.IsParsedProductEqualToProduct(u, productToUpdate))
?? throw new Exception("Cannot find any parsed product");
productToUpdate.Price = parsedProduct.Price;
productToUpdate.Mass = parsedProduct.Mass;
}
public ZoneSession GetSessionByCharacter(Character character)
{
if (character == Character.None)
{
return(null);
}
return(_sessions.FirstOrDefault(s => s.Character == character));
}
public TestComposition WithAssemblies(ImmutableHashSet <Assembly> assemblies)
{
if (assemblies == Assemblies)
{
return(this);
}
var testAssembly = assemblies.FirstOrDefault(IsTestAssembly);
Contract.ThrowIfFalse(testAssembly == null, $"Test assemblies are not allowed in test composition: {testAssembly}. Specify explicit test parts instead.");
return(new TestComposition(assemblies, Parts, ExcludedPartTypes));
public override IDependency BeforeAdd(
string projectPath,
ITargetFramework targetFramework,
IDependency dependency,
ImmutableDictionary <string, IDependency> .Builder worldBuilder,
ImmutableHashSet <IDependency> .Builder topLevelBuilder,
Dictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviders,
HashSet <string> projectItemSpecs,
out bool filterAnyChanges)
{
filterAnyChanges = false;
IDependency resultDependency = dependency;
var matchingDependency = topLevelBuilder.FirstOrDefault(
x => !x.Id.Equals(dependency.Id, StringComparison.OrdinalIgnoreCase) &&
x.ProviderType.Equals(dependency.ProviderType, StringComparison.OrdinalIgnoreCase) &&
x.Caption.Equals(dependency.Caption, StringComparison.OrdinalIgnoreCase));
// if found node with same caption, or if there were nodes with same caption but with Alias already applied
var shouldApplyAlias = (matchingDependency == null)
? topLevelBuilder.Any(
x => !x.Id.Equals(dependency.Id) &&
x.ProviderType.Equals(dependency.ProviderType, StringComparison.OrdinalIgnoreCase) &&
x.Caption.Equals(
string.Format(CultureInfo.CurrentCulture, "{0} ({1})", dependency.Caption, x.OriginalItemSpec),
StringComparison.OrdinalIgnoreCase))
: true;
if (shouldApplyAlias)
{
filterAnyChanges = true;
if (matchingDependency != null)
{
matchingDependency = matchingDependency.SetProperties(caption: matchingDependency.Alias);
worldBuilder.Remove(matchingDependency.Id);
worldBuilder.Add(matchingDependency.Id, matchingDependency);
topLevelBuilder.Remove(matchingDependency);
topLevelBuilder.Add(matchingDependency);
}
resultDependency = resultDependency.SetProperties(caption: dependency.Alias);
}
return(resultDependency);
}
TreeNode GetPrimarySelectedNode(ImmutableHashSet <TreeNode> nodesSet)
{
TreeNode node;
if (nodesSet.Contains(primarySelectionCandidate1))
{
node = primarySelectionCandidate1;
}
else if (nodesSet.Contains(primarySelectionCandidate2))
{
node = primarySelectionCandidate2;
}
else
{
node = nodesSet.FirstOrDefault();
}
return(node);
}
public bool TryUpdateKVNodes(IEnumerable <KeyValueNode> kvNodes, out ConsulState updatedState)
{
var missingKeyPrefixes = _missingKeyPrefixes;
if (kvNodes.Any())
{
var noLongerMissingKeyPrefix = _missingKeyPrefixes.FirstOrDefault(keyPrefix => kvNodes.First().FullKey.StartsWith(keyPrefix));
if (noLongerMissingKeyPrefix != null)
{
missingKeyPrefixes = _missingKeyPrefixes.Remove(noLongerMissingKeyPrefix);
}
}
if (_kvStore.TryUpdate(kvNodes, out var updatedKvStore))
{
updatedState = new ConsulState(_services, updatedKvStore, missingKeyPrefixes);
return(true);
}
updatedState = null;
return(false);
}
private NugetDependenciesChange ProcessResolvedChanges(IProjectSubscriptionUpdate projectSubscriptionUpdate,
ImmutableHashSet <IDependencyNode> rootTreeNodes)
{
var changes = projectSubscriptionUpdate.ProjectChanges;
var resolvedChanges = ResolvedReferenceRuleNames.Where(x => changes.Keys.Contains(x))
.Select(ruleName => changes[ruleName])
.ToImmutableHashSet();
var dependenciesChange = new NugetDependenciesChange();
var newDependencies = new HashSet <DependencyMetadata>();
foreach (var change in resolvedChanges)
{
if (!change.Difference.AnyChanges)
{
continue;
}
foreach (string removedItemSpec in change.Difference.RemovedItems)
{
var metadata = CurrentSnapshot.RemoveDependency(removedItemSpec);
var itemNode = rootTreeNodes.FirstOrDefault(
x => x.Id.ItemSpec.Equals(removedItemSpec, StringComparison.OrdinalIgnoreCase));
if (itemNode != null)
{
dependenciesChange.RemovedNodes.Add(metadata);
}
}
foreach (string changedItemSpec in change.Difference.ChangedItems)
{
var properties = GetProjectItemProperties(change.After, changedItemSpec);
if (properties == null)
{
continue;
}
var metadata = CurrentSnapshot.UpdateDependency(changedItemSpec, properties);
var itemNode = rootTreeNodes.FirstOrDefault(
x => x.Id.ItemSpec.Equals(changedItemSpec, StringComparison.OrdinalIgnoreCase));
if (itemNode != null)
{
dependenciesChange.UpdatedNodes.Add(metadata);
}
}
foreach (string addedItemSpec in change.Difference.AddedItems)
{
var properties = GetProjectItemProperties(change.After, addedItemSpec);
if (properties == null)
{
continue;
}
var newDependency = CurrentSnapshot.AddDependency(addedItemSpec, properties);
newDependencies.Add(newDependency);
}
}
// Note: currently deisgn time build is limited and is not aware of conditional on TFM
// PackageReference items: Unresolved PackageReference items for conditional TFMs are not sent.
// Thus we will display conditional PackageReferences if they were resolved and are in assets.json.
// This limitation should go away, when we have final design for cross target dependencies and
// DesignTime build.
var allTargetsDependencies = CurrentSnapshot.GetUniqueTopLevelDependencies();
if (allTargetsDependencies.Count == 0)
{
return(dependenciesChange);
}
var addedTopLevelDependencies = newDependencies.Where(
x => allTargetsDependencies.Contains(x.ItemSpec) && !x.IsImplicitlyDefined);
foreach (var addedDependency in addedTopLevelDependencies)
{
dependenciesChange.AddedNodes.Add(addedDependency);
}
return(dependenciesChange);
}
