Exemple #1
0
 public static void Serialize(string projectFilePath, ProjectFileModel projectFile, bool overwrite = true)
 {
     using (var fileStream = FileStreamHelper.NewWrite(projectFilePath, overwrite))
         using (var xmlWriter = XmlWriterHelper.New(fileStream))
         {
             projectFile.ProjectElement.Value.Save(xmlWriter);
         }
 }
Exemple #2
0
        public Task SerializeAsync(Stream stream, XDocumentVisualStudioProjectFile xElementVisualStudioProjectFile, IMessageSink messageSink)
        {
            using (var xmlWriter = XmlWriterHelper.New(stream))
            {
                var projectXElement = xElementVisualStudioProjectFile.ProjectXElement;

                var xProjectXElement = projectXElement.Value;

                var xDocument = xProjectXElement.Document;

                xDocument.Save(xmlWriter); // No SaveAsync() in .NET Standard.
            }

            return(Task.CompletedTask);
        }
Exemple #3
0
        private async Task CompareRoundTripBasicXmlSerializedFiles()
        {
            var inputProjectFilePath  = this.TestingDataDirectoryContentPathsProvider.GetExampleVisualStudioProjectFilePath01();
            var outputProjectFilePath = this.TemporaryDirectoryFilePathProvider.GetTemporaryDirectoryFilePath("ProjectFile01.csproj");

            //var xElement = XElement.Load(inputProjectFilePath); // Does not preserve insignifcant whitespace.
            var xElement = XElement.Load(inputProjectFilePath, LoadOptions.PreserveWhitespace); // Because insignification whitespace is preserved, project file is identical when round-tripped.

            //xElement.Save(outputProjectFilePath); // Adds an XML document declaration, so no good a a project file serializer.

            using (var fileStream = FileStreamHelper.NewWrite(outputProjectFilePath))
                using (var xmlWriter = XmlWriterHelper.New(fileStream))
                {
                    xElement.Save(xmlWriter);
                }

            await this.CompareFiles(inputProjectFilePath, outputProjectFilePath, "Files not equal.");
        }
Exemple #4
0
        private Task TestXmlWriter()
        {
            var projectFilePath       = this.TestingDataDirectoryContentPathsProvider.GetExampleVisualStudioProjectFilePath01();
            var outputProjectFilePath = this.TemporaryDirectoryFilePathProvider.GetTemporaryDirectoryFilePath("ProjectFile01.csproj");

            var xElement = XElement.Load(projectFilePath); // No async version.

            //using (var writer = new StreamWriter(outputProjectFilePath))
            //using (var customXmlWriter = new CustomXmlWriter(writer))
            //using (var xmlWriter = XmlWriterHelper.New(outputProjectFilePath))
            //using (var customXmlWriter = new CustomXmlWriter(xmlWriter))
            using (var stringWriter = new StringWriter())
            {
                using (var xmlWriter = XmlWriterHelper.New(stringWriter))
                {
                    //writer.AutoFlush = true;

                    xElement.Save(xmlWriter);
                    //xElement.Save(customXmlWriter);
                }

                var text = stringWriter.ToString();

                var matches = Regex.Matches(text, @"^\s*<ItemGroup>", RegexOptions.Multiline);
                foreach (Match match in matches)
                {
                    var prefix      = text.Substring(0, match.Index);
                    var replacement = "\n" + match.Value;
                    var suffix      = text.Substring(match.Index + match.Length);

                    var newText = prefix + replacement + suffix;
                    text = newText;
                }

                File.WriteAllText(outputProjectFilePath, text);
            }

            return(Task.CompletedTask);
        }
        public async Task Serialize(Stream stream, ProjectFile projectFile, IMessageSink messageSink)
        {
            var projectXElement = await this.VisualStudioProjectFileToXElementConverter.ToProjectXElement(projectFile, messageSink);

            // Save to a StringWriter, then adjust the string to have the desired extra line breaks before serialization.
            using (var stringWriter = new StringWriter())
            {
                using (var xmlWriter = XmlWriterHelper.New(stringWriter))
                {
                    projectXElement.Value.WriteTo(xmlWriter); // No async version.
                }

                var text = stringWriter.ToString();

                var prefixNewLineMatchPatterns = new[]
                {
                    $@"^\s*<{ProjectFileXmlElementName.ItemGroup}>",
                    $@"^\s*<{ProjectFileXmlElementName.PropertyGroup}>",
                    $@"^\s*</{ProjectFileXmlElementName.Project}>",
                };

                var modifiedText = text;
                foreach (var prefixNewLineMatchPattern in prefixNewLineMatchPatterns)
                {
                    var matches         = Regex.Matches(modifiedText, prefixNewLineMatchPattern, RegexOptions.Multiline); // Include beginning-of-line whitespace.
                    var numberOfMatches = matches.Count;

                    var substrings = new string[numberOfMatches]; // Not +1 since we will deal with the last sub-string separately.

                    var startIndex = 0;
                    for (int iMatch = 0; iMatch < numberOfMatches; iMatch++)
                    {
                        var match = matches[iMatch];

                        var substring = modifiedText.Substring(startIndex, match.Index);
                        substrings[iMatch] = substring;
                    }

                    var lastMatch     = matches[numberOfMatches - 1];
                    var lastSubstring = lastMatch.Index + lastMatch.Length == modifiedText.Length + 1 ? String.Empty : modifiedText.Substring(lastMatch.Index + lastMatch.Length);

                    var stringBuilder = new StringBuilder();

                    for (int iMatch = 0; iMatch < numberOfMatches; iMatch++)
                    {
                        var substring = substrings[iMatch];
                        var match     = matches[iMatch];

                        var replacement = "\r\n" + match.Value;

                        stringBuilder.Append(substring);
                        stringBuilder.Append(replacement);
                    }

                    stringBuilder.Append(lastSubstring);

                    modifiedText = stringBuilder.ToString();
                }

                using (var textWriter = new StreamWriter(stream))
                {
                    await textWriter.WriteAsync(modifiedText);
                }
            }
        }