public override Task <IEnumerable <IDependencyNode> > SearchAsync(IDependencyNode node, string searchTerm)
{
lock (_snapshotLock)
{
DependencyMetadata rootDependency = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(node.Id.ItemSpec, out rootDependency))
{
return(Task.FromResult <IEnumerable <IDependencyNode> >(null));
}
var flatMatchingDependencies = new HashSet <DependencyMetadata>();
foreach (var kvp in CurrentSnapshot.DependenciesWorld)
{
if (kvp.Value.Name.ToLowerInvariant().Contains(searchTerm) ||
kvp.Value.Version.ToLowerInvariant().Contains(searchTerm))
{
flatMatchingDependencies.Add(kvp.Value);
}
}
if (flatMatchingDependencies.Count <= 0)
{
return(Task.FromResult <IEnumerable <IDependencyNode> >(null));
}
return(Task.FromResult <IEnumerable <IDependencyNode> >(
SearchRecursive(rootDependency, flatMatchingDependencies)));
}
}
private IList <IDependencyNode> SearchRecursive(DependencyMetadata rootDependency,
HashSet <DependencyMetadata> flatMatchingDependencies)
{
var matchingNodes = new List <IDependencyNode>();
foreach (var childDependency in rootDependency.DependenciesItemSpecs)
{
DependencyMetadata childDependencyMetadata = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(childDependency, out childDependencyMetadata))
{
continue;
}
var children = SearchRecursive(childDependencyMetadata, flatMatchingDependencies);
if (children.Count > 0 || flatMatchingDependencies.Contains(childDependencyMetadata))
{
var currentDependencyNode = CreateDependencyNode(childDependencyMetadata, topLevel: false);
matchingNodes.Add(currentDependencyNode);
foreach (var child in children)
{
currentDependencyNode.AddChild(child);
}
}
}
return(matchingNodes);
}
/// <summary>
/// Until we have a proper design for displaying cross-target dependencies, we show all
/// in one list.
/// </summary>
/// <returns></returns>
public HashSet <string> GetUniqueTopLevelDependencies()
{
HashSet <string> topLevelDependenciesNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
HashSet <string> topLevelDependenciesItemSpecs = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var target in Targets)
{
DependencyMetadata targetMetadata = null;
if (!DependenciesWorld.TryGetValue(target.Key, out targetMetadata))
{
continue;
}
foreach (var dependencyItemSpec in targetMetadata.DependenciesItemSpecs)
{
DependencyMetadata dependencyMetadata = null;
if (!DependenciesWorld.TryGetValue(dependencyItemSpec, out dependencyMetadata))
{
continue;
}
if (topLevelDependenciesNames.Contains(dependencyMetadata.Name))
{
// we already have this dependency form other target
continue;
}
topLevelDependenciesNames.Add(dependencyMetadata.Name);
topLevelDependenciesItemSpecs.Add(dependencyItemSpec);
}
}
return(topLevelDependenciesItemSpecs);
}
/// <summary>
/// Adds the metadata.
/// </summary>
/// <param name="metadata">The metadata.</param>
public void AddMetadata(DependencyMetadata metadata)
{
lock (syncroot)
{
_metadata.Add(metadata);
}
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
if (dependencyMetadata.ImplementedInterfaces.Contains(typeof(IDecorator)))
{
return(new RegistrationResult(this, true));
}
//first lets see if the type in question is an open generic and if it implements an open generic interface?
if (dependencyMetadata.DependencyType.IsGenericTypeDefinition)
{
var genericInterfaces = dependencyMetadata.ImplementedInterfaces.Where(x => x.IsGenericType);
var results = new List <DependencyRegistration>(genericInterfaces.Count());
foreach (var interfaceType in genericInterfaces)
{
var rb = Builder.RegisterGeneric(dependencyMetadata.DependencyType);
this.SetLifetime(dependencyMetadata.ServiceLifetime, rb);// this.CreateGenericRegistrationWithLifetime(dependencyMetadata.DependencyType, dependencyMetadata.ServiceLifetime);
var namedDependency = dependencyMetadata.NamedDependency;
if (namedDependency != null)
{
rb.Keyed(namedDependency, interfaceType).As(interfaceType);
if (dependencyMetadata.Decorator != null)
{
// builder.RegisterDecorator<INationalAffiliationLookupService>(
// (c, inner) => new NationalAffiliationLookupServiceDecorator(inner, c.Resolve<ICache>()),
// fromKey: "decoratable"
//).As<IExpirable>().As<INationalAffiliationLookupService>().SingleInstance();
}
}
else
{
rb.As(interfaceType);
}
//user has defined interception
if (dependencyMetadata.Interceptor != null)
{
// rb.InterceptedBy(dependencyMetadata.Interceptor);
}
else if (Configuration.InterceptableTypes != null && Configuration.InterceptableTypes.Any())
{
var classInterception = Configuration.InterceptableTypes.FirstOrDefault(x => x.TypeToIntercept.IsAssignableFrom(dependencyMetadata.DependencyType));
if (classInterception != null)
{
// rb.InterceptedBy(classInterception.InterceptionType);
}
}
results.Add(new DependencyRegistration
{
DependencyTypeName = dependencyMetadata.DependencyType.FullName,
ImplementedInterfaceName = interfaceType.FullName,
DependencyKey = dependencyMetadata.NamedDependency,
ServiceLifetime = dependencyMetadata.ServiceLifetime.ToString()
});
}
return(new RegistrationResult(this, true, results));
}
return(new RegistrationResult(this, false));
}
private IDependencyNode CreateDependencyNode(DependencyMetadata dependencyMetadata,
DependencyNodeId id = null,
bool topLevel = true)
{
if (id == null)
{
var uniqueToken = topLevel ? null : Guid.NewGuid().ToString();
id = new DependencyNodeId(ProviderType,
dependencyMetadata.ItemSpec,
ResolvedPackageReference.PrimaryDataSourceItemType,
uniqueToken);
}
// here based on DependencyType we create a corresponding node
IDependencyNode dependencyNode = null;
switch (dependencyMetadata.DependencyType)
{
case DependencyType.Package:
dependencyNode = new PackageDependencyNode(
id,
name: dependencyMetadata.Name,
caption: dependencyMetadata.FriendlyName,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
case DependencyType.Assembly:
case DependencyType.FrameworkAssembly:
dependencyNode = new PackageAssemblyDependencyNode(
id,
caption: dependencyMetadata.Name,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
case DependencyType.AnalyzerAssembly:
dependencyNode = new PackageAnalyzerAssemblyDependencyNode(
id,
caption: dependencyMetadata.Name,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
default:
dependencyNode = new PackageUnknownDependencyNode(
id,
caption: dependencyMetadata.Name,
flags: NuGetSubTreeNodeFlags,
properties: dependencyMetadata.Properties,
resolved: dependencyMetadata.Resolved);
break;
}
return(dependencyNode);
}
public override bool Equals(object obj)
{
DependencyMetadata other = obj as DependencyMetadata;
if (other != null)
{
return(Equals(other));
}
return(false);
}
public bool Equals(DependencyMetadata other)
{
if (other != null &&
other.ItemSpec.Equals(ItemSpec, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
return(false);
}
public override IDependencyNode GetDependencyNode(DependencyNodeId id)
{
lock (_snapshotLock)
{
IDependencyNode node = null;
if (CurrentSnapshot.NodesCache.TryGetValue(id, out node))
{
return(node);
}
DependencyMetadata dependencyMetadata = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(id.ItemSpec, out dependencyMetadata))
{
return(null);
}
// create node and it's direct children
node = CreateDependencyNode(dependencyMetadata, id);
CurrentSnapshot.NodesCache.Add(id, node);
var frameworkAssemblies = new List <DependencyMetadata>();
foreach (var childItemSpec in dependencyMetadata.DependenciesItemSpecs)
{
DependencyMetadata childDependencyMetadata = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(childItemSpec, out childDependencyMetadata))
{
continue;
}
if (childDependencyMetadata.DependencyType == DependencyType.FrameworkAssembly)
{
frameworkAssemblies.Add(childDependencyMetadata);
continue;
}
node.AddChild(CreateDependencyNode(childDependencyMetadata, topLevel: false));
}
if (frameworkAssemblies.Count > 0)
{
var frameworkAssembliesNode = CreateFrameworkAssembliesFolder();
node.AddChild(frameworkAssembliesNode);
foreach (var fxAssemblyMetadata in frameworkAssemblies)
{
frameworkAssembliesNode.AddChild(CreateDependencyNode(fxAssemblyMetadata, topLevel: false));
}
}
return(node);
}
}
public DependencyMetadata AddDependency(string itemSpec, IImmutableDictionary <string, string> properties)
{
if (!itemSpec.Contains("/") && !Targets.ContainsKey(itemSpec))
{
var newTarget = new TargetMetadata(properties);
Targets.Add(itemSpec, newTarget);
}
var newDependency = new DependencyMetadata(itemSpec, properties);
DependenciesWorld[itemSpec] = newDependency;
return(newDependency);
}
public DependencyMetadata RemoveDependency(string itemSpec)
{
DependencyMetadata removedMetadata = null;
if (!DependenciesWorld.TryGetValue(itemSpec, out removedMetadata))
{
return(null);
}
DependenciesWorld.Remove(itemSpec);
RemoveNodeFromCache(itemSpec);
return(removedMetadata);
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
if (dependencyMetadata.ImplementedInterfaces.Contains(typeof(IModule)))
{
//we are using AutoFac's module registration
IModule module = Activator.CreateInstance(dependencyMetadata.DependencyType.AsType()) as IModule;
if (module != null)
{
Builder.RegisterModule(module);
return(new RegistrationResult(this, true, Produce(new DependencyRegistration {
DependencyTypeName = dependencyMetadata.DependencyType.Name
})));
}
}
return(new RegistrationResult(this, false));
}
private bool DoesNodeMatchByNameOrItemSpec(IDependencyNode node, string itemSpecToCheck)
{
bool?result = false;
DependencyMetadata metadata = null;
if (CurrentSnapshot.DependenciesWorld.TryGetValue(node.Id.ItemSpec, out metadata))
{
result = metadata?.Name?.Equals(itemSpecToCheck, StringComparison.OrdinalIgnoreCase);
}
if (!result.HasValue || !result.Value)
{
result = node.Id.ItemSpec.Equals(itemSpecToCheck, StringComparison.OrdinalIgnoreCase);
}
return(result.Value);
}
private IDependencyNode GetDependencyNode(DependencyNodeId id, DependencyMetadata dependencyMetadata)
{
// create node and it's direct children
var node = CreateDependencyNode(dependencyMetadata, id);
CurrentSnapshot.NodesCache.Add(id, node);
var frameworkAssemblies = new List <DependencyMetadata>();
foreach (var childItemSpec in dependencyMetadata.DependenciesItemSpecs)
{
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(childItemSpec, out DependencyMetadata childDependencyMetadata))
{
continue;
}
if (childDependencyMetadata.DependencyType == DependencyType.FrameworkAssembly)
{
frameworkAssemblies.Add(childDependencyMetadata);
continue;
}
else if (childDependencyMetadata.Properties.TryGetValue(MetadataKeys.IsImplicitlyDefined, out string isImplicitPackageString) &&
bool.TryParse(isImplicitPackageString, out bool isImplicitPackage) &&
isImplicitPackage)
{
// we don't want to show implicit packages at all, since they are SDK's
continue;
}
node.AddChild(CreateDependencyNode(childDependencyMetadata, topLevel: false));
}
if (frameworkAssemblies.Count > 0)
{
var frameworkAssembliesNode = CreateFrameworkAssembliesFolder();
node.AddChild(frameworkAssembliesNode);
foreach (var fxAssemblyMetadata in frameworkAssemblies)
{
frameworkAssembliesNode.AddChild(CreateDependencyNode(fxAssemblyMetadata, topLevel: false));
}
}
return(node);
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
if (dependencyMetadata.ImplementedInterfaces.Any(x => x.IsGenericType))
{
var decoratorType = dependencyMetadata.ImplementedInterfaces.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition().Equals(typeof(IDecorator <>)));
if (decoratorType != null)
{
var trueType = decoratorType.GetGenericArguments()[0];
Builder.RegisterDecorator(dependencyMetadata.DependencyType, trueType);
//we are using AutoFac's module registration
// var rb = Builder.RegisterType(dependencyMetadata.DependencyType.AsType()).AsSelf();
return(new RegistrationResult(this, true, Produce(new DependencyRegistration {
DependencyTypeName = dependencyMetadata.DependencyType.Name
})));
}
}
return(new RegistrationResult(this, false));
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
var result = base.Register(dependencyMetadata);
if (result.RuleExecuted)
{
return(result);
}
var results = new List <DependencyRegistration>();
foreach (var interfaceType in dependencyMetadata.ImplementedInterfaces)
{
var namedDependency = dependencyMetadata.NamedDependency;
var rb = Builder.RegisterType(dependencyMetadata.DependencyType.AsType());
this.SetLifetime(dependencyMetadata.ServiceLifetime, rb);
if (namedDependency != null)
{
rb.Keyed(namedDependency, interfaceType).As(interfaceType);
}
else
{
rb.As(interfaceType);
}
//user has defined interception
if (dependencyMetadata.Interceptor != null)
{
// rb.EnableClassInterceptors();
// rb.InterceptedBy(dependencyMetadata.Interceptor);
Builder.RegisterType(dependencyMetadata.Interceptor);
}
results.Add(new DependencyRegistration
{
DependencyTypeName = dependencyMetadata.DependencyType.FullName,
ImplementedInterfaceName = interfaceType.FullName,
DependencyKey = dependencyMetadata.NamedDependency,
ServiceLifetime = dependencyMetadata.ServiceLifetime.ToString()
});
}
return(new RegistrationResult(this, true, results));
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
if (dependencyMetadata.DiscoveryInterface.Equals(typeof(ISelfTransient)))
{
//we are using AutoFac's module registration
Builder.RegisterType(dependencyMetadata.DependencyType.AsType()).AsSelf().InstancePerDependency();
return(new RegistrationResult(this, true, Produce(new DependencyRegistration {
DependencyTypeName = dependencyMetadata.DependencyType.Name
})));
}
else if (dependencyMetadata.DiscoveryInterface.Equals(typeof(ISelfSingleton)))
{
//we are using AutoFac's module registration
Builder.RegisterType(dependencyMetadata.DependencyType.AsType()).AsSelf().SingleInstance();
return(new RegistrationResult(this, true, Produce(new DependencyRegistration {
DependencyTypeName = dependencyMetadata.DependencyType.Name
})));
}
return(new RegistrationResult(this, false));
}
public DependencyMetadata RemoveDependency(string itemSpec)
{
DependencyMetadata removedMetadata = null;
if (!DependenciesWorld.TryGetValue(itemSpec, out removedMetadata))
{
return(null);
}
DependenciesWorld.Remove(itemSpec);
RemoveNodeFromCache(itemSpec);
if (!itemSpec.Contains("/") && Targets.ContainsKey(itemSpec))
{
Targets.Remove(itemSpec);
}
return(removedMetadata);
}
public Dictionary <string, string> GetDependencyProperties(string itemSpec)
{
var result = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
DependencyMetadata dependency = null;
if (!CurrentSnapshot.DependenciesWorld.TryGetValue(itemSpec, out dependency))
{
return(result);
}
result.Add("Version", dependency.Version);
result.Add("Name", dependency.Name);
result.Add("Type", dependency.DependencyType.ToString());
result.Add("Path", dependency.Path);
result.Add("Dependencies", string.Join(";", dependency.DependenciesItemSpecs));
result.Add("Resolved", dependency.Resolved.ToString());
return(result);
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
var result = base.Register(dependencyMetadata);
if (result.RuleExecuted)
{
return(result);
}
var results = new List <DependencyRegistration>();
foreach (var interfaceType in dependencyMetadata.ImplementedInterfaces)
{
var namedDependency = dependencyMetadata.NamedDependency;
Builder.Configure(c =>
{
if (dependencyMetadata.Decorator != null)
{
var strategy = c.ExportDecorator(dependencyMetadata.DependencyType).As(interfaceType);
}
else
{
var strategy = c.Export(dependencyMetadata.DependencyType).As(interfaceType);
SetLifetime(dependencyMetadata.ServiceLifetime, strategy);
if (namedDependency != null)
{
strategy.AsKeyed(interfaceType, namedDependency);
}
}
});
results.Add(new DependencyRegistration
{
DependencyTypeName = dependencyMetadata.DependencyType.FullName,
ImplementedInterfaceName = interfaceType.FullName,
DependencyKey = dependencyMetadata.NamedDependency,
ServiceLifetime = dependencyMetadata.ServiceLifetime.ToString()
});
}
return(new RegistrationResult(this, true, results));
}
public override RegistrationResult Register(DependencyMetadata dependencyMetadata)
{
//first lets see if the type in question is an open generic and if it implements an open generic interface?
if (dependencyMetadata.DependencyType.IsGenericTypeDefinition)
{
var genericInterfaces = dependencyMetadata.ImplementedInterfaces.Where(x => x.IsGenericType);
var results = new List <DependencyRegistration>(genericInterfaces.Count());
foreach (var interfaceType in genericInterfaces)
{
var namedDependency = dependencyMetadata.NamedDependency;
Builder.Configure(c =>
{
if (dependencyMetadata.Decorator != null)
{
var strategy = c.ExportDecorator(dependencyMetadata.DependencyType).As(interfaceType);
}
else
{
var strategy = c.Export(dependencyMetadata.DependencyType).As(interfaceType);
SetLifetime(dependencyMetadata.ServiceLifetime, strategy);
if (namedDependency != null)
{
strategy.AsKeyed(interfaceType, namedDependency);
}
}
});
results.Add(new DependencyRegistration
{
DependencyTypeName = dependencyMetadata.DependencyType.FullName,
ImplementedInterfaceName = interfaceType.FullName,
DependencyKey = dependencyMetadata.NamedDependency,
ServiceLifetime = dependencyMetadata.ServiceLifetime.ToString()
});
return(new RegistrationResult(this, true, results));
}
}
return(new RegistrationResult(this, false));
}
public DependencyMetadata UpdateDependency(string itemSpec, IImmutableDictionary <string, string> properties)
{
DependencyMetadata dependencyMetadata = null;
if (!DependenciesWorld.TryGetValue(itemSpec, out dependencyMetadata))
{
return(null);
}
if (!itemSpec.Contains("/"))
{
TargetMetadata targetMetadata = null;
if (Targets.TryGetValue(itemSpec, out targetMetadata))
{
targetMetadata.SetProperties(properties);
}
}
dependencyMetadata.SetProperties(properties);
RemoveNodeFromCache(itemSpec);
return(dependencyMetadata);
}
public abstract RegistrationResult Register(DependencyMetadata dependencyMetadata);
public override bool Execute()
{
// populate unique targets
var targets = new Dictionary <string, DependencyMetadata>(StringComparer.OrdinalIgnoreCase);
var dependencies = new Dictionary <string, DependencyMetadata>(StringComparer.OrdinalIgnoreCase);
var files = new Dictionary <string, DependencyMetadata>(StringComparer.OrdinalIgnoreCase);
foreach (var targetDef in TargetDefinitions)
{
if (targetDef.ItemSpec.Contains("/"))
{
// skip "target/rid"s and only consume actuall targets
continue;
}
var target = new DependencyMetadata(runtimeIdentifier: targetDef.GetMetadata("RuntimeIdentifier"),
targetFrameworkMoniker: targetDef.GetMetadata("TargetFramework"),
frameworkName: targetDef.GetMetadata("FrameworkName"),
frameworkVersion: targetDef.GetMetadata("FrameworkVersion"),
type: "Target");
targets[targetDef.ItemSpec] = target;
}
// populate unique packages
foreach (var packageDef in PackageDefinitions)
{
// TODO How to determine if package is resolved or not?
// TODO Paths are unresolved
// TODO diagnostics
var dependencyType = packageDef.GetMetadata("Type");
if (string.IsNullOrEmpty(dependencyType))
{
dependencyType = "Package";
}
var dependency = new DependencyMetadata(name: packageDef.GetMetadata("Name"),
version: packageDef.GetMetadata("Version"),
type: dependencyType,
path: packageDef.GetMetadata("Path"));
dependencies[packageDef.ItemSpec] = dependency;
}
// populate unique files
foreach (var fileDef in FileDefinitions)
{
// TODO How to determine a framework assembly
var dependencyType = fileDef.GetMetadata("Type");
if (string.IsNullOrEmpty(dependencyType))
{
dependencyType = "Assembly";
}
var name = Path.GetFileName(fileDef.ItemSpec);
var assembly = new DependencyMetadata(name: name,
type: dependencyType,
path: fileDef.GetMetadata("Path"));
files[fileDef.ItemSpec] = assembly;
}
var dependenciesWorld = new Dictionary <string, DependencyMetadata>(StringComparer.OrdinalIgnoreCase);
// populate package dependencies
foreach (var packageDependency in PackageDependencies)
{
var currentPackageId = packageDependency.ItemSpec;
var parentTargetId = packageDependency.GetMetadata("ParentTarget");
if (parentTargetId.Contains("/"))
{
// skip "target/rid"s and only consume actual targets
continue;
}
// add package to the world
var parentPackageId = packageDependency.GetMetadata("ParentPackage");
var currentPackageUniqueId = $"{parentTargetId}/{currentPackageId}";
DependencyMetadata currentPackageDependency = null;
if (!dependenciesWorld.TryGetValue(currentPackageUniqueId, out currentPackageDependency))
{
if (dependencies.Keys.Contains(currentPackageId))
{
// add current package to dependencies world
dependenciesWorld[currentPackageUniqueId] = dependencies[currentPackageId];
}
}
// update parent
var parentDependencyId = $"{parentTargetId}/{parentPackageId}".Trim('/');;
DependencyMetadata parentDependency = null;
if (dependenciesWorld.TryGetValue(parentDependencyId, out parentDependency))
{
parentDependency.Dependencies.Add(currentPackageId);
}
else
{
// create new parent
if (!string.IsNullOrEmpty(parentPackageId))
{
parentDependency = dependencies[parentPackageId];
}
else
{
parentDependency = targets[parentTargetId];
}
if (parentDependency == null)
{
continue;
}
parentDependency.Dependencies.Add(currentPackageId);
dependenciesWorld[parentDependencyId] = parentDependency;
}
}
// populate assembly dependencies
foreach (var assemblyDependency in FileDependencies)
{
var currentAssemblyId = assemblyDependency.ItemSpec;
var fileGroup = assemblyDependency.GetMetadata("FileGroup");
if (string.IsNullOrEmpty(fileGroup) ||
!fileGroup.Equals("CompileTimeAssembly") ||
currentAssemblyId.EndsWith("_._"))
{
continue;
}
var parentTargetId = assemblyDependency.GetMetadata("ParentTarget");
if (parentTargetId.Contains("/"))
{
// skip "target/rid"s and only consume actual targets
continue;
}
// add package to the world
var parentPackageId = assemblyDependency.GetMetadata("ParentPackage");
var currentAssemblyUniqueId = $"{parentTargetId}/{currentAssemblyId}";
DependencyMetadata currentDependency = null;
if (!dependenciesWorld.TryGetValue(currentAssemblyUniqueId, out currentDependency))
{
if (files.Keys.Contains(currentAssemblyId))
{
// add current package to dependencies world
dependenciesWorld[currentAssemblyUniqueId] = files[currentAssemblyId];
}
}
// update parent
var parentDependencyId = $"{parentTargetId}/{parentPackageId}".Trim('/');;
DependencyMetadata parentDependency = null;
if (dependenciesWorld.TryGetValue(parentDependencyId, out parentDependency))
{
parentDependency.Dependencies.Add(currentAssemblyId);
}
else
{
// create new parent
if (!string.IsNullOrEmpty(parentPackageId))
{
parentDependency = dependencies[parentPackageId];
}
else
{
parentDependency = targets[parentTargetId];
}
if (parentDependency == null)
{
continue;
}
parentDependency.Dependencies.Add(currentAssemblyId);
dependenciesWorld[parentDependencyId] = parentDependency;
}
}
// Test data
//var myAssembly1Dependency = new DependencyMetadata("MyAssembly1.dll", "1.0.0.0", "Assembly", "c/temp/MyPackage/MyAssembly1.dll");
//var myAssembly2Dependency = new DependencyMetadata("MyAssembly2.dll", "2.0.0.0", "Assembly", "c/temp/MyPackage/MyAssembly2.dll");
//var myGacAssembly1Dependency = new DependencyMetadata("MyFrameworkAssembly1.dll", "1.0.0.0", "FrameworkAssembly", "c/temp/MyPackage/MyGacAssembly1.dll");
//var myGacAssembly2Dependency = new DependencyMetadata("MyFrameworkAssembly2.dll", "2.0.0.0", "FrameworkAssembly", "c/temp/MyPackage/MyGacAssembly2.dll");
//var myPackageDependency2 = new DependencyMetadata("MyPackage2", "1.0.0.0", "Package", "c/temp/MyPackage2");
//var myAssembly3Dependency = new DependencyMetadata("MyAssembly3.dll", "2.0.0.0", "Assembly", "c/temp/MyPackage/MyAssembly3.dll");
//var myGacAssembly3Dependency = new DependencyMetadata("MyFrameworkAssembly3.dll", "1.0.0.0", "FrameworkAssembly", "c/temp/MyPackage/MyGacAssembly3.dll");
//myPackageDependency2.Dependencies.Add("MyAssembly3.dll/1.0.0.0/c/temp/MyPackage");
//myPackageDependency2.Dependencies.Add("MyFrameworkAssembly3.dll/1.0.0.0/c/temp/MyPackage");
//var myPackageDependency = new DependencyMetadata("MyPackage", "1.0.0.0", "Package", "c/temp/MyPackage");
//myPackageDependency.Dependencies.Add("MyPackage2/1.0.0.0");
//myPackageDependency.Dependencies.Add("MyAssembly1.dll/1.0.0.0/c/temp/MyPackage");
//myPackageDependency.Dependencies.Add("MyAssembly2.dll/2.0.0.0/c/temp/MyPackage");
//myPackageDependency.Dependencies.Add("MyFrameworkAssembly1.dll/1.0.0.0/c/temp/MyPackage");
//myPackageDependency.Dependencies.Add("MyFrameworkAssembly2.dll/2.0.0.0/c/temp/MyPackage");
//dependenciesWorld[".NETFramework,Version=v4.6"].Dependencies.Add("MyPackage/1.0.0.0");
//dependenciesWorld[".NETFramework,Version=v4.6"].Dependencies.Add("MyPackage2/1.0.0.0");
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyPackage/1.0.0.0", myPackageDependency);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyPackage2/1.0.0.0", myPackageDependency2);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyAssembly1.dll/1.0.0.0/c/temp/MyPackage", myAssembly1Dependency);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyAssembly2.dll/2.0.0.0/c/temp/MyPackage", myAssembly2Dependency);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyFrameworkAssembly1.dll/1.0.0.0/c/temp/MyPackage", myGacAssembly1Dependency);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyFrameworkAssembly2.dll/2.0.0.0/c/temp/MyPackage", myGacAssembly2Dependency);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyAssembly3.dll/1.0.0.0/c/temp/MyPackage", myAssembly3Dependency);
//dependenciesWorld.Add(".NETFramework,Version=v4.6/MyFrameworkAssembly3.dll/1.0.0.0/c/temp/MyPackage", myGacAssembly3Dependency);
DependenciesWorld = dependenciesWorld.Select(kvp =>
{
var newTaskItem = new TaskItem(kvp.Key);
newTaskItem.SetMetadata("RuntimeIdentifier", kvp.Value.RuntimeIdentifier);
newTaskItem.SetMetadata("TargetFramework", kvp.Value.TargetFrameworkMoniker);
newTaskItem.SetMetadata("FrameworkName", kvp.Value.FrameworkName);
newTaskItem.SetMetadata("FrameworkVersion", kvp.Value.FrameworkVersion);
newTaskItem.SetMetadata("Name", kvp.Value.Name);
newTaskItem.SetMetadata("Version", kvp.Value.Version);
newTaskItem.SetMetadata("DependencyType", kvp.Value.DependencyType);
newTaskItem.SetMetadata("Path", kvp.Value.Path);
newTaskItem.SetMetadata("Dependencies", string.Join(";", kvp.Value.Dependencies));
return(newTaskItem);
}).ToArray();
return(true);
}
private NugetDependenciesChange ProcessUnresolvedChanges(IProjectSubscriptionUpdate projectSubscriptionUpdate)
{
var unresolvedChanges = projectSubscriptionUpdate.ProjectChanges.Values
.Where(cd => !ResolvedReferenceRuleNames.Any(ruleName =>
string.Equals(ruleName,
cd.After.RuleName,
StringComparison.OrdinalIgnoreCase)))
.ToDictionary(d => d.After.RuleName, d => d, StringComparer.OrdinalIgnoreCase);
var dependenciesChange = new NugetDependenciesChange();
foreach (var change in unresolvedChanges.Values)
{
if (!change.Difference.AnyChanges)
{
continue;
}
foreach (string removedItemSpec in change.Difference.RemovedItems)
{
DependencyMetadata metadata = null;
if (TopLevelDependencies.TryGetValue(removedItemSpec, out metadata))
{
TopLevelDependencies.Remove(removedItemSpec);
dependenciesChange.RemovedNodes.Add(metadata);
}
}
foreach (string changedItemSpec in change.Difference.ChangedItems)
{
var properties = GetProjectItemProperties(change.After, changedItemSpec);
if (properties == null)
{
continue;
}
DependencyMetadata metadata = null;
if (TopLevelDependencies.TryGetValue(changedItemSpec, out metadata))
{
metadata = CreateUnresolvedMetadata(changedItemSpec, properties);
TopLevelDependencies[changedItemSpec] = metadata;
dependenciesChange.UpdatedNodes.Add(metadata);
}
}
foreach (string addedItemSpec in change.Difference.AddedItems)
{
var properties = GetProjectItemProperties(change.After, addedItemSpec);
if (properties == null)
{
continue;
}
DependencyMetadata metadata = null;
if (!TopLevelDependencies.TryGetValue(addedItemSpec, out metadata))
{
metadata = CreateUnresolvedMetadata(addedItemSpec, properties);
TopLevelDependencies.Add(addedItemSpec, metadata);
dependenciesChange.AddedNodes.Add(metadata);
}
}
}
return(dependenciesChange);
}
public MetadataWrapper(DependencyMetadata<TDependency> metadata) => this.Metadata = metadata;
