private void Uninstall(IPackage package, IDependentsResolver dependentsResolver, IPackageRepository repository)
{
// If this package isn't part of the current graph (i.e. hasn't been visited yet) and
// is marked for removal, then do nothing. This is so we don't get unnecessary duplicates.
if (!Marker.Contains(package) && _operations.Contains(package, PackageAction.Uninstall))
{
return;
}
// Uninstall the conflicting package. We set throw on conflicts to false since we've
// already decided that there were no conflicts based on the above code.
var resolver = new UninstallWalker(repository,
dependentsResolver,
TargetFramework,
NullLogger.Instance,
removeDependencies: !IgnoreDependencies,
forceRemove: false)
{
ThrowOnConflicts = false
};
foreach (var operation in resolver.ResolveOperations(package))
{
_operations.AddOperation(operation);
}
}
private void Uninstall(IPackage package, IDependentsResolver dependentsResolver, IPackageRepository repository)
{
// If we explicitly want to uninstall this package, then remove it from the retainment queue.
_packagesToKeep.Remove(package);
// If this package isn't part of the current graph (i.e. hasn't been visited yet) and
// is marked for removal, then do nothing. This is so we don't get unnecessary duplicates.
if (!Marker.Contains(package) && _operations.Contains(package, PackageAction.Uninstall))
{
return;
}
// Uninstall the conflicting package. We set throw on conflicts to false since we've
// already decided that there were no conflicts based on the above code.
var resolver = new UninstallWalker(
repository,
dependentsResolver,
TargetFramework,
NullLogger.Instance,
removeDependencies: !IgnoreDependencies,
forceRemove: false)
{
DisableWalkInfo = this.DisableWalkInfo,
ThrowOnConflicts = false
};
foreach (var operation in resolver.ResolveOperations(package))
{
// If the operation is Uninstall, we don't want to uninstall the package if it is in the "retainment" queue.
if (operation.Action == PackageAction.Install || !_packagesToKeep.Contains(operation.Package))
{
_operations.AddOperation(operation);
}
}
}
private bool IsConnected(IPackage package)
{
// We could cache the results of this lookup
if (Marker.Contains(package))
{
return(true);
}
IEnumerable <IPackage> dependents = DependentsResolver.GetDependents(package);
return(dependents.Any() && dependents.All(IsConnected));
}
public override void Add(Marker marker)
{
if (marker == null)
{
throw new ArgumentNullException(nameof(marker));
}
if (Contains(marker) || marker.Contains(this))
{
return;
}
_referenceList.Add(marker);
}
protected override void OnBeforePackageWalk(IPackage package)
{
ConflictResult conflictResult = GetConflict(package.Id);
if (conflictResult == null)
{
return;
}
// If the conflicting package is the same as the package being installed
// then no-op
if (PackageEqualityComparer.IdAndVersion.Equals(package, conflictResult.Package))
{
return;
}
// First we get a list of dependents for the installed package.
// Then we find the dependency in the foreach dependent that this installed package used to satisfy.
// We then check if the resolved package also meets that dependency and if it doesn't it's added to the list
// i.e A1 -> C >= 1
// B1 -> C >= 1
// C2 -> []
// Given the above graph, if we upgrade from C1 to C2, we need to see if A and B can work with the new C
var dependents = from dependentPackage in GetDependents(conflictResult)
where !IsDependencySatisfied(dependentPackage, package)
select dependentPackage;
if (dependents.Any())
{
throw CreatePackageConflictException(package, conflictResult.Package, dependents);
}
else if (package.Version < conflictResult.Package.Version)
{
throw new InvalidOperationException(
String.Format(CultureInfo.CurrentCulture,
NuGetResources.NewerVersionAlreadyReferenced, package.Id));
}
else if (package.Version > conflictResult.Package.Version)
{
// If this package isn't part of the current graph (i.e. hasn't been visited yet) and
// is marked for removal, then do nothing. This is so we don't get unnecessary duplicates.
if (!Marker.Contains(conflictResult.Package) &&
_operations.Contains(conflictResult.Package, PackageAction.Uninstall))
{
return;
}
// Uninstall the conflicting package. We set throw on conflicts to false since we've
// already decided that there were no conflicts based on the above code.
var resolver = new UninstallWalker(conflictResult.Repository,
conflictResult.DependentsResolver,
NullLogger.Instance,
removeDependencies: !IgnoreDependencies,
forceRemove: false)
{
ThrowOnConflicts = false
};
foreach (var operation in resolver.ResolveOperations(conflictResult.Package))
{
_operations.AddOperation(operation);
}
}
}
