address build warnings

Author: Nick Iliev

extend-fiddler/addmenuitems.md

@@ -12,7 +12,7 @@ To add menu actions to the **Tools** menu or context menus or add options to the
 
 1. Create and execute a .REG file as follows:
 
-	```
+	```txt
 	[HKEY_CURRENT_USER\Software\Microsoft\Fiddler2\MenuExt\&YourMenuItemName]
 	"Command"="YourExeName.exe"
 	"Parameters"="Your Parameters To Pass To The EXE"

extend-fiddler/extendwithdotnet.md

@@ -23,28 +23,26 @@ See [Build extension assemblies to run in both Fiddler Classic versions 2 and 4]
 ## Debugging
 
 + To ensure that exceptions and other extension-related errors are not silently caught: [set](slug://ExtensionsForv2Andv4) the `fiddler.debug.extensions.showerrors` preference to **True**. 
-+ To output logging information to the **Log** tab: [set][1] the `fiddler.debug.extensions.verbose`
-
-[1]: http://fiddler.wikidot.com/prefsaction
++ To output logging information to the **Log** tab: set the `fiddler.debug.extensions.verbose`
 
 ## Direct Fiddler Classic to load extension assemblies
 
 + To make the extensions available to the current user, install extension assembly DLLs to:
 
-	```
-	%localappdata%\Programs\Fiddler\Scripts
-	OR
-	%userprofile%\Documents\Fiddler2\Scripts
-	```
+```txt
+%localappdata%\Programs\Fiddler\Scripts
+OR
+%userprofile%\Documents\Fiddler2\Scripts
+```
 
 + Set the **Fiddler.RequiredVersion** attribute in your **AssemblyInfo.cs** file (or elsewhere in your code) as follows:
 
-	```c#
-	using Fiddler;
+```c#
+using Fiddler;
 
-	// Extension requires Fiddler Classic 2.2.8.6+ because it uses types introduced in v2.2.8...
-	[assembly: Fiddler.RequiredVersion("2.2.8.6")]
-	```
+// Extension requires Fiddler Classic 2.2.8.6+ because it uses types introduced in v2.2.8...
+[assembly: Fiddler.RequiredVersion("2.2.8.6")]
+```
 
 ## Sample Extension: Step by Step
 
@@ -66,41 +64,41 @@ See [Build extension assemblies to run in both Fiddler Classic versions 2 and 4]
  + In the Solution Explorer, right click the project.  Choose Properties.
  + On the Build Events tab, add the following to the Post-build event command line:
 
-	```c#
-	copy "$(TargetPath)" "%userprofile%\Documents\Fiddler2\Scripts\$(TargetFilename)"
-	```
+```c#
+copy "$(TargetPath)" "%userprofile%\Documents\Fiddler2\Scripts\$(TargetFilename)"
+```
 
 Modify the default class1.cs (or create a new class) in your project as follows:
 
-	```c#
-	using System;
-	using System.Windows.Forms;
-	using Fiddler;
+```c#
+using System;
+using System.Windows.Forms;
+using Fiddler;
 
-	[assembly: Fiddler.RequiredVersion("2.3.5.0")]
+[assembly: Fiddler.RequiredVersion("2.3.5.0")]
 
-	public class Violin : IAutoTamper    // Ensure class is public, or Fiddler won't see it!
-	{
-		string sUserAgent = "";
+public class Violin : IAutoTamper    // Ensure class is public, or Fiddler won't see it!
+{
+	string sUserAgent = "";
 
-		public Violin(){
-		/* NOTE: It's possible that Fiddler Classic UI isn't fully loaded yet, so don't add any UI in the constructor.
+	public Violin(){
+	/* NOTE: It's possible that Fiddler Classic UI isn't fully loaded yet, so don't add any UI in the constructor.
 
-			But it's also possible that AutoTamper* methods are called before OnLoad (below), so be
-			sure any needed data structures are initialized to safe values here in this constructor */
-		
-			sUserAgent = "Violin";
-		}
+		But it's also possible that AutoTamper* methods are called before OnLoad (below), so be
+		sure any needed data structures are initialized to safe values here in this constructor */
+	
+		sUserAgent = "Violin";
+	}
 
-		public void OnLoad(){ /* Load your UI here */ }
-		public void OnBeforeUnload() { }
+	public void OnLoad(){ /* Load your UI here */ }
+	public void OnBeforeUnload() { }
 
-		public void AutoTamperRequestBefore(Session oSession){
-		oSession.oRequest["User-Agent"] = sUserAgent;
-		}
-		public void AutoTamperRequestAfter(Session oSession){}
-		public void AutoTamperResponseBefore(Session oSession){}
-		public void AutoTamperResponseAfter(Session oSession){}
-		public void OnBeforeReturningError(Session oSession){}
+	public void AutoTamperRequestBefore(Session oSession){
+	oSession.oRequest["User-Agent"] = sUserAgent;
 	}
-	```
+	public void AutoTamperRequestAfter(Session oSession){}
+	public void AutoTamperResponseBefore(Session oSession){}
+	public void AutoTamperResponseAfter(Session oSession){}
+	public void OnBeforeReturningError(Session oSession){}
+}
+```

extend-fiddler/extensionsforv2andv4.md

@@ -9,51 +9,51 @@ position: 11
 
 + If you want your extension Assembly to run in both Fiddler2 and Fiddler4, build it for .NET Framework v2 and avoid taking any dependencies on any classes that were removed or moved in the later version of the Framework. (The only instance I'm aware of is the Microsoft JScript.NET code compiler, whose classes were moved around a bit).
 
- You'll also need to ensure that if you use any methods that are deprecated (for example, calling **Assembly.LoadFrom** with the overload that takes an **Evidence** parameter) you do so only conditionally. For example:
-
-	```c#
-	if (CONFIG.bRunningOnCLRv4)
-	{
-		a = Assembly.LoadFrom(oFile.FullName);
-	}
-	else
-	{
-		a = Assembly.LoadFrom(oFile.FullName, evidenceFiddler);
-	}
-	```
+ You'll also need to ensure that if you use any methods that are deprecated (for example, calling `Assembly.LoadFrom` with the overload that takes an `Evidence` parameter) you do so only conditionally. For example:
+
+```c#
+if (CONFIG.bRunningOnCLRv4)
+{
+	a = Assembly.LoadFrom(oFile.FullName);
+}
+else
+{
+	a = Assembly.LoadFrom(oFile.FullName, evidenceFiddler);
+}
+```
 
  All of the extensions from the Fiddler Classic website are compiled against Fiddler Classic v2.
 
 + Alternatively, you can simply build two versions of your DLL, one version targeting .NET Framework v4 and one targeting .NET Framework v2.
 
  This is how Fiddler Classic itself is built. Basically, just add a "clone" version of your v2-targeted Project to the same Solution. Use the **Add > Existing Item** context menu to add the .CS files from the v2-targeted project to the v4-targeted project, but when selecting the files, be very sure to use the split button on the file picker dialog and choose **Add as Link**. On the v4 Project's **Properties > Build** tab, add a **Conditional Compilation** symbol like DOTNET4. You can then put any .NETv4-specific code behind conditional compilation:
 
-	```c#
-	#if DOTNET4
+```c#
+#if DOTNET4
 
-	// ... code targeting .NETv4
+// ... code targeting .NETv4
 
-	#else
+#else
 
-	// ... code targeting .NETv2
+// ... code targeting .NETv2
 
-	#endif
-	```
+#endif
+```
 
  Your extension may install the appropriately-targeted version based on the content of the **InstalledVersion** registry key found inside:
 
-	```
-	HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Fiddler2
-	``` 
+```txt
+HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Fiddler2
+``` 
 
  The .NET2 version of Fiddler Classic is much more popular than the .NETv4 version at this time. When the .NET Framework v4.5 is released, I may move the v4 project over to v4.5. Among other things, that would allow me to take advantage of the new built-in .ZIP classes in that later framework.
 
 + What about the RequiredVersion attribute?
 
  Fiddler Classic v4 is "smart"-- if your extension specifies
 
-	```
-	[assembly: Fiddler.RequiredVersion("2.1.0.1")]
-	```
+```txt
+[assembly: Fiddler.RequiredVersion("2.1.0.1")]
+```
 
  When Fiddler Classic v4 loads it, it will require version 4.3.9.9 or later.

extend-fiddler/importerexporterinterfaces.md

@@ -9,48 +9,48 @@ position: 7
 
 ## Thread Safety and FiddlerCore
 
-+ Currently, the **ISessionImporter** and **ISessionExporter** interfaces are called on the **MAIN** UI thread. This is almost certain to change in the future, so you should ensure that your classes are thread safe and that they do not attempt to directly manipulate the Fiddler Classic UI. 
++ Currently, the `ISessionImporter` and `ISessionExporter` interfaces are called on the **MAIN** UI thread. This is almost certain to change in the future, so you should ensure that your classes are thread safe and that they do not attempt to directly manipulate the Fiddler Classic UI. 
 
 + Manipulation of the Fiddler Classic UI is further ill-advised because Fiddler Classic itself may not be loaded; FiddlerCore may be hosting your Importer/Exporter directly. In order to support FiddlerCore, it's advised that you support the Filename key (with string value of a fully-qualified path) in the dictOptions parameter, and consider supporting a Silent key (value as boolean) as well.
 
 ## The ISessionImporter Interface
 
-Extensions that implement the **ISessionImporter** interface (which implements the **IDisposable** interface) are called when the user uses the **File > Import** menu option.
+Extensions that implement the `ISessionImporter` interface (which implements the `IDisposable` interface) are called when the user uses the **File > Import** menu option.
 
-	```c#
-	public interface ISessionImporter : IDisposable
-	{
-		Session[] ImportSessions(string sImportFormat, Dictionary<string, object> dictOptions,
-				EventHandler<ProgressCallbackEventArgs> evtProgressNotifications);
-	}
+```c#
+public interface ISessionImporter : IDisposable
+{
+	Session[] ImportSessions(string sImportFormat, Dictionary<string, object> dictOptions,
+			EventHandler<ProgressCallbackEventArgs> evtProgressNotifications);
+}
 
-	```
+```
 
-The method returns an array of **Session** objects created from the Import of the data.
+The method returns an array of `Session` objects created from the Import of the data.
 
-The **dictOptions** dictionary may be null, or may contain a set of string-keyed objects. Most importers support specification of a filename. For example:
+The `dictOptions` dictionary may be null, or may contain a set of string-keyed objects. Most importers support specification of a filename. For example:
 
-	```c#
-	dictOptions["Filename"] = "C:\\test.file"
-	```
+```c#
+dictOptions["Filename"] = "C:\\test.file"
+```
 
 ## The ISessionExporter Interface
 
 This class is defined by Fiddler Classic and allows you to report on the progress of an import or export operation.
 
 If the completion ratio cannot be determined, simply pass 0 or a "guess" between 0 and 1.0.
 
-If the Cancel flag is set on the **ProgressCallbackEventArgs** object after being passed to the **evtProgressNotifications** callback, import or export should gracefully terminate as soon as possible.
-
-	```c#
-	public class ProgressCallbackEventArgs: EventArgs
-	{
-		public ProgressCallbackEventArgs(float flCompletionRatio, string sProgressText)
-		public string ProgressText { get; }
-		public string PercentComplete { get; }
-		public bool Cancel { get; set; }
-	}
-	```
+If the Cancel flag is set on the `ProgressCallbackEventArgs` object after being passed to the `evtProgressNotifications` callback, import or export should gracefully terminate as soon as possible.
+
+```c#
+public class ProgressCallbackEventArgs: EventArgs
+{
+	public ProgressCallbackEventArgs(float flCompletionRatio, string sProgressText)
+	public string ProgressText { get; }
+	public string PercentComplete { get; }
+	public bool Cancel { get; set; }
+}
+```
 
 ## See Also