Separate Done() and Dispose() in ProcessInputWriter NativeCommandProcessor.cs

Sergei Vorobev · Sergei Vorobev · commit 825352faa365 · 2016-11-15T17:16:44.000-08:00
diff --git a/src/System.Management.Automation/engine/NativeCommandProcessor.cs b/src/System.Management.Automation/engine/NativeCommandProcessor.cs
@@ -1701,7 +1701,7 @@ internal void Add(object input)
         {
             if (_stopping || _streamWriter == null)
             {
-                // if _streamWriter is already null, then we already called Done()
+                // if _streamWriter is already null, then we already called Dispose()
                 // so we should just discard the input.
                 return;
             }
@@ -1736,7 +1736,7 @@ private void AddTextInputFromFormattedArray(Array formattedObjects)
                 {
                     // we are assuming that process is already finished
                     // we should just stop processing at this point
-                    this.Done();
+                    this.Dispose();
                     // stop foreach execution
                     break;
                 }
@@ -1753,7 +1753,7 @@ private void AddXmlInput(object input)
             {
                 // we are assuming that process is already finished
                 // we should just stop processing at this point
-                this.Done();
+                this.Dispose();
             }
         }
 
@@ -1812,36 +1812,26 @@ internal void Stop()
             _stopping = true;
         }
 
-        /// <summary>
-        /// This method wait for writer thread to finish.
-        /// </summary>
-        internal void Done()
+        internal void Dispose()
         {
-            // we allow call Done() multiply times.
+            // we allow call Dispose() multiply times.
             // For example one time from ProcessRecord() code path,
             // when we detect that process already finished
-            // and once from Complete() code path.
-            // Even though Done() could be called multiple times,
-            // the calls are on the same thread, so there is no race condition.
+            // and once from Done() code path.
+            // Even though Dispose() could be called multiple times,
+            // the calls are on the same thread, so there is no race condition
             if (_pipeline != null)
             {
-                var finalResults = _pipeline.End();
                 _pipeline.Dispose();
                 _pipeline = null;
-                // AddTextInputFromFormattedArray can recursively call Done(),
-                // if the downstream process already exited.
-                // to Prevent it, we first finalize the pipeline and set it to null,
-                // then calling the result processing for the last time
-                AddTextInputFromFormattedArray(finalResults);
             }
 
             if (_xmlSerializer != null)
             {
-                _xmlSerializer.Done();
                 _xmlSerializer = null;
             }
 
-            // streamWriter is present, only if we call Start method
+            // streamWriter can be null if we didn't call Start method
             if (_streamWriter != null)
             {
                 try
@@ -1857,6 +1847,29 @@ internal void Done()
                 _streamWriter = null;
             }
         }
+
+        internal void Done()
+        {
+            if (_inputFormat == NativeCommandIOFormat.Xml)
+            {
+                if (_xmlSerializer != null)
+                {
+                    _xmlSerializer.Done();
+                }
+            }
+            else // Text
+            {
+                // if _pipeline == null, we already called Dispose(),
+                // for example, because downstream process finished
+                if (_pipeline != null)
+                {
+                    var finalResults = _pipeline.End();
+                    AddTextInputFromFormattedArray(finalResults);
+                }
+            }
+
+            Dispose();
+        }
     }
    
 #if !CORECLR // There is no GUI application on OneCore, so powershell on OneCore should always have a console attached.

Original file line number	Diff line number	Diff line change
`@@ -1701,7 +1701,7 @@ internal void Add(object input)`
`1701`	`1701`	`{`
`1702`	`1702`	`if (_stopping \|\| _streamWriter == null)`
`1703`	`1703`	`{`
`1704`		`- // if _streamWriter is already null, then we already called Done()`
	`1704`	`+ // if _streamWriter is already null, then we already called Dispose()`
`1705`	`1705`	`// so we should just discard the input.`
`1706`	`1706`	`return;`
`1707`	`1707`	`}`
`@@ -1736,7 +1736,7 @@ private void AddTextInputFromFormattedArray(Array formattedObjects)`
`1736`	`1736`	`{`
`1737`	`1737`	`// we are assuming that process is already finished`
`1738`	`1738`	`// we should just stop processing at this point`
`1739`		`- this.Done();`
	`1739`	`+ this.Dispose();`
`1740`	`1740`	`// stop foreach execution`
`1741`	`1741`	`break;`
`1742`	`1742`	`}`
`@@ -1753,7 +1753,7 @@ private void AddXmlInput(object input)`
`1753`	`1753`	`{`
`1754`	`1754`	`// we are assuming that process is already finished`
`1755`	`1755`	`// we should just stop processing at this point`
`1756`		`- this.Done();`
	`1756`	`+ this.Dispose();`
`1757`	`1757`	`}`
`1758`	`1758`	`}`
`1759`	`1759`
`@@ -1812,36 +1812,26 @@ internal void Stop()`
`1812`	`1812`	`_stopping = true;`
`1813`	`1813`	`}`
`1814`	`1814`
`1815`		`- /// <summary>`
`1816`		`- /// This method wait for writer thread to finish.`
`1817`		`- /// </summary>`
`1818`		`- internal void Done()`
	`1815`	`+ internal void Dispose()`
`1819`	`1816`	`{`
`1820`		`- // we allow call Done() multiply times.`
	`1817`	`+ // we allow call Dispose() multiply times.`
`1821`	`1818`	`// For example one time from ProcessRecord() code path,`
`1822`	`1819`	`// when we detect that process already finished`
`1823`		`- // and once from Complete() code path.`
`1824`		`- // Even though Done() could be called multiple times,`
`1825`		`- // the calls are on the same thread, so there is no race condition.`
	`1820`	`+ // and once from Done() code path.`
	`1821`	`+ // Even though Dispose() could be called multiple times,`
	`1822`	`+ // the calls are on the same thread, so there is no race condition`
`1826`	`1823`	`if (_pipeline != null)`
`1827`	`1824`	`{`
`1828`		`- var finalResults = _pipeline.End();`
`1829`	`1825`	`_pipeline.Dispose();`
`1830`	`1826`	`_pipeline = null;`
`1831`		`- // AddTextInputFromFormattedArray can recursively call Done(),`
`1832`		`- // if the downstream process already exited.`
`1833`		`- // to Prevent it, we first finalize the pipeline and set it to null,`
`1834`		`- // then calling the result processing for the last time`
`1835`		`- AddTextInputFromFormattedArray(finalResults);`
`1836`	`1827`	`}`
`1837`	`1828`
`1838`	`1829`	`if (_xmlSerializer != null)`
`1839`	`1830`	`{`
`1840`		`- _xmlSerializer.Done();`
`1841`	`1831`	`_xmlSerializer = null;`
`1842`	`1832`	`}`
`1843`	`1833`
`1844`		`- // streamWriter is present, only if we call Start method`
	`1834`	`+ // streamWriter can be null if we didn't call Start method`
`1845`	`1835`	`if (_streamWriter != null)`
`1846`	`1836`	`{`
`1847`	`1837`	`try`
`@@ -1857,6 +1847,29 @@ internal void Done()`
`1857`	`1847`	`_streamWriter = null;`
`1858`	`1848`	`}`
`1859`	`1849`	`}`
	`1850`	`+`
	`1851`	`+ internal void Done()`
	`1852`	`+ {`
	`1853`	`+ if (_inputFormat == NativeCommandIOFormat.Xml)`
	`1854`	`+ {`
	`1855`	`+ if (_xmlSerializer != null)`
	`1856`	`+ {`
	`1857`	`+ _xmlSerializer.Done();`
	`1858`	`+ }`
	`1859`	`+ }`
	`1860`	`+ else // Text`
	`1861`	`+ {`
	`1862`	`+ // if _pipeline == null, we already called Dispose(),`
	`1863`	`+ // for example, because downstream process finished`
	`1864`	`+ if (_pipeline != null)`
	`1865`	`+ {`
	`1866`	`+ var finalResults = _pipeline.End();`
	`1867`	`+ AddTextInputFromFormattedArray(finalResults);`
	`1868`	`+ }`
	`1869`	`+ }`
	`1870`	`+`
	`1871`	`+ Dispose();`
	`1872`	`+ }`
`1860`	`1873`	`}`
`1861`	`1874`
`1862`	`1875`	`#if !CORECLR // There is no GUI application on OneCore, so powershell on OneCore should always have a console attached.`