What is the correct syntax for Find.Execute on Interop.Word?

Question

I am facing a problem while using Microsoft.Office.Interop.Word - trying to perform a find and replace with format design change.
The most frustrating thing here is that I am not getting an error, just the Word application get stuck.
I was checking all around how to use the Find.Execute on Interop Word for it need to pass Object - and I could not figure out what is the correct way of doing so, and i found different approaches while exploring this issue.
Lets assume that I have this kind of code:

using msWord = Microsoft.Office.Interop.Word;

msWord.Document doc = msWord.Application.ActiveDocument; // sets the document

Range range = doc.StoryRanges[WdStoryType.wdMainTextStory]; // sets the range as the main text

string textToFind = "ABC";    // the text to be found
string textToReplace = "123"; // the text to replace with
bool useWildCards = false;    // whether to use wildcards on search
bool makeBold = true;         // whether to change the font format to bold or non-bold

Now I am performing the find and replace function like this:

FindAndReplaceWithFormating(range ,textToFind ,textToReplace, useWildCards, makeBold)

Now my question is how to make this FindAndReplaceWithFormating function in the correct and most appropriate method. For that i have here 3 different approaches:

private void FindAndReplaceWithFormating(Range range, string textToFind,
string textToReplace, bool useWildCards, bool makeBold)
{
range.Find.ClearFormatting();
range.Find.Replacement.ClearFormatting();
range.Find.Replacement.Font.Bold = makeBold; // the format design must come like this.

// here comes the rest of the code according to the chosen method...

}

Method 1:

range.Find.Text = textToFind;
range.Find.Replacement.Text = textToReplace;
range.Find.MatchWildcards = useWildCards;
range.Find.Forward = true;
range.Find.Format = true;
range.Find.Wrap = msWord.WdFindWrap.wdFindContinue;
object replaceAll = msWord.WdReplace.wdReplaceAll;
object missing = Missing.Value; // using System.Reflection;

// all ref are missing. only replaceAll ref is sent
range.Find.Execute(ref missing, ref missing, ref missing, ref missing, ref missing,
ref missing, ref missing, ref missing, ref missing, ref missing,
ref replaceAll, ref missing, ref missing, ref missing, ref missing);

Method 2:

object missing = Missing.Value;
object FindText = textToFind;
object MatchCase = missing;
object MatchWholeWord = missing;
object MatchWildcards = useWildCards;
object MatchSoundsLike = missing;
object MatchAllWordForms = missing;
object Forward = true;
object Wrap = msWord.WdFindWrap.wdFindContinue;
object Format = true;
object ReplaceWith = textToReplace;
object Replace = msWord.WdReplace.wdReplaceAll;
object MatchKashida = missing;
object MatchDiacritics = missing;
object MatchAlefHamza = missing;
object MatchControl = missing;

// all are sent as object.
find.Execute(ref FindText, ref MatchCase, ref MatchWholeWord, ref MatchWildcards, ref MatchSoundsLike,
ref MatchAllWordForms, ref Forward, ref Wrap, ref Format, ref ReplaceWith, ref Replace,
ref MatchKashida, ref MatchDiacritics, ref MatchAlefHamza, ref MatchControl);

Method 2b:

// same as above just objects are sent without ref
// ...
find.Execute(FindText, MatchCase, MatchWholeWord, MatchWildcards, MatchSoundsLike,
MatchAllWordForms, Forward, Wrap, Format, ReplaceWith, Replace,
MatchKashida, MatchDiacritics, MatchAlefHamza, MatchControl);

Method 3:

range.Find.Execute(textToFind, false, false, useWildCards, false, false, true, 
msWord.WdFindWrap.wdFindContinue, true, textToReplace, msWord.WdReplace.wdReplaceAll,
false, false, false, false);

Answer 1

Thanks to @Yosef Bernal I have checked this again and found out that all methods are correct. But there seems to be a most preferred method for it's clarity is to declare all attributes, and arrange it in a "readable" way like this:

range.Find.Execute(
FindText: "ABC",               // The text to be searched for.
ReplaceWith: "123",         // The replacment text.

MatchWildcards: false,       // Determines if the text to find contains wildcards.

Forward: true,                      // Determines if the find operation searches forward through the document.
Format: false,                       // Determine if formatting is included in the find operation.
Wrap: WdFindWrap.wdFindContinue,    // What happens if the search begins at a point other than the beginning of the document and the end of the document is reached (or vice versa if Forward is set to False) or if the search text isn't found in the specified selection or range.
Replace: WdReplace.wdReplaceAll,    // Specifies how many replacements to be made: one , none or all.

MatchCase: false,                   // Determines if the find operation is case-sensitive.
MatchWholeWord: false,              // Determines if the find operation locates only entire words and not text that's part of a larger word.
MatchSoundsLike: false,             // Determines if words that sound similar to the text to find are returned by the find operation.
MatchAllWordForms: false,           // Determines if all forms of the text to find are found by the find operation (for instance, if the text to find is "sit," "sat" and "sitting" are found as well).

MatchKashida: false,                // Match text with matching kashidas in an Arabic language document.
MatchDiacritics: false,             // Matching diacritics in a right-to-left language document.
MatchAlefHamza: false,              // Match text with matching alef hamzas in an Arabic language document.
MatchControl: false                 // Matching bidirectional control characters in a right-to-left language document.
);

EDIT : Just be aware of a Interop.Word bug while using UndoRecord with ReplaceAll - see here & here