Esempio n. 1
0
        public override bool Execute()
        {
            var root           = new DirectoryInfo(Root);
            var csProjectFiles = root.GetFiles("*.csproj", SearchOption.AllDirectories);
            var projectXmls    =
                csProjectFiles.Select(pf => pf.FullName)
                .Distinct(StringComparer.InvariantCultureIgnoreCase)
                .ToDictionary(fn => fn, fn =>
            {
                try
                {
                    return(XDocument.Load(fn));
                }
                catch
                {
                    return(null);
                }
            },
                              StringComparer.InvariantCultureIgnoreCase).Where(px => px.Value != null).ToArray();

            var versionComparer = new VersionComparer();

            var references =
                projectXmls.SelectMany(
                    projectXmlPair =>
                    GetReferences(projectXmlPair.Value)
                    .Select(r => new { FileName = projectXmlPair.Key, XmlDocument = projectXmlPair.Value, Xml = r.Item1, AssemblyName = r.Item2, VersionString = r.Item3 })).ToArray();
            var assemblyVersions = new Dictionary <string, Tuple <string, XElement> >(StringComparer.InvariantCultureIgnoreCase);

            foreach (var reference in references)
            {
                if (assemblyVersions.ContainsKey(reference.AssemblyName))
                {
                    if (
                        versionComparer.Compare(reference.VersionString,
                                                assemblyVersions[reference.AssemblyName].Item1) > 0)
                    {
                        assemblyVersions[reference.AssemblyName] = new Tuple <string, XElement>(reference.VersionString,
                                                                                                reference.Xml);
                    }
                }
                else
                {
                    assemblyVersions.Add(reference.AssemblyName,
                                         new Tuple <string, XElement>(reference.VersionString, reference.Xml));
                }
            }

            foreach (var referenceAndDocument in references.GroupBy(r => new { r.FileName, r.XmlDocument }))
            {
                var documentChanged = false;

                foreach (var reference in referenceAndDocument)
                {
                    if (!assemblyVersions.ContainsKey(reference.AssemblyName))
                    {
                        continue;
                    }
                    var latestVersionTuple = assemblyVersions[reference.AssemblyName];
                    var latestVersion      = new { VersionString = latestVersionTuple.Item1, Xml = latestVersionTuple.Item2 };

                    if (latestVersion.VersionString.Equals("0.0.0.0"))
                    {
                        continue;
                    }

                    if (reference.VersionString.Equals(latestVersion.VersionString))
                    {
                        continue;
                    }

                    var includeAttribute    = reference.Xml.Attribute("Include");
                    var desiredIncludeValue = latestVersion.Xml.Attribute("Include").Value;

                    if (includeAttribute.Value != desiredIncludeValue)
                    {
                        includeAttribute.Value = desiredIncludeValue;
                        documentChanged        = true;
                    }

                    var specificVersionElement =
                        reference.Xml.Elements()
                        .SingleOrDefault(
                            e =>
                            e.Name.LocalName.Equals("SpecificVersion",
                                                    StringComparison.InvariantCultureIgnoreCase));

                    if (specificVersionElement == null)
                    {
                        specificVersionElement = new XElement(XName.Get("SpecificVersion", reference.Xml.GetDefaultNamespace().NamespaceName))
                        {
                            Value = "True"
                        };
                        reference.Xml.Add(specificVersionElement);
                        documentChanged = true;
                    }
                    else if (!bool.Parse(specificVersionElement.Value))
                    {
                        specificVersionElement.Value = "True";
                        documentChanged = true;
                    }
                    //var desiredHintPath =
                    //    latestVersion.Xml.Elements().SingleOrDefault(e => e.Name.LocalName.Equals("HintPath"));
                    //if(desiredHintPath == null)
                    //    continue;

                    //var hintPathElement =
                    //    reference.Xml.Elements().SingleOrDefault(e => e.Name.LocalName.Equals("HintPath"));

                    //if (hintPathElement == null)
                    //{
                    //    hintPathElement = new XElement(XName.Get("HintPath", reference.Xml.GetDefaultNamespace().NamespaceName)) { Value = desiredHintPath.Value };
                    //    reference.Xml.Add(hintPathElement);
                    //    documentChanged = true;
                    //}
                    //else if (hintPathElement.Value != desiredHintPath.Value)
                    //{
                    //    hintPathElement.Value = desiredHintPath.Value;
                    //    documentChanged = true;
                    //}
                }
                if (!documentChanged)
                {
                    continue;
                }

                referenceAndDocument.Key.XmlDocument.Save(referenceAndDocument.Key.FileName);
            }
            return(true);
        }