I am building a Windows phone App and I am facing this problem: I have a `FirstRun()` function in the `App.xaml.cs` file which checks if the app runs for the first time. I got 2 message boxes which show me each occasion (First run and not first run). The problem is that when running the app for the first time I get the message "First run" but after that, without proceeding, I get the other message "Not first run" and the program does not proceed to the functions that need to be executed when running for the first time. What can cause this "double" call for the `IsFirstRun()` function and also return a different result? Here are the functions:

```
 public static bool IsFirstRun()
    {
        if (!settings.Contains(FIRST_RUN_FLAG)) //First time running
        {
            settings.Add(FIRST_RUN_FLAG, false);
            return true;
        }
        return false;   
    }

```

And the UriMapper which helps me get to the right page: 

public class FirstRunUriMapper : UriMapperBase
 {
 public override Uri MapUri(Uri uri)
 {

```
        if (uri.OriginalString == "/LaunchPage.xaml")
        {
            MessageBox.Show("Searching for LaunchPage...");
            if (App.IsFirstRun())
            {
                MessageBox.Show("First run...Should show introductionPage...");
                uri = new Uri("/MainPage.xaml", UriKind.Relative);
            }
            else
            {
                MessageBox.Show("...Should show MainPage...");
                uri = new Uri("/IntroductionPage.xaml", UriKind.Relative);
            }
        }
        return uri;
    }
}

```

**EDIT:**
As asked, I provide the whole class with the modified `UriMapper` that works fine now, but still can't find what causes the double `MapUri()` method call:

```
  public class FirstRunUriMapper : UriMapperBase
{

    public override Uri MapUri(Uri uri)
    {

        if (uri.OriginalString == "/LaunchPage.xaml")
        {
            if (App.FirstRun)
            {
                if (App.IsFirstRun())
                {
                    uri = new Uri("/IntroductionPage.xaml", UriKind.Relative);
                }
                else
                {
                    uri = new Uri("/IntroductionPage.xaml", UriKind.Relative);
                    App.FirstRun = false;
                }
            }
            else
            {
                uri = new Uri("/MainPage.xaml", UriKind.Relative);
            }
        }
        return uri;
    }
}

```

And the `App.xaml.cs` class:

public partial class App : Application
 {

```
    private static string FIRST_RUN_FLAG = "FIRST_RUN_FLAG";
    private static IsolatedStorageSettings settings = IsolatedStorageSettings.ApplicationSettings;
    public static bool FirstRun = true;

    /// <summary>
    /// Provides easy access to the root frame of the Phone Application.
    /// </summary>
    /// <returns>The root frame of the Phone Application.</returns>
    public static PhoneApplicationFrame RootFrame { get; private set; }

    /// <summary>
    /// Checks if the app runs for the first time
    /// </summary>
    /// <returns>True if the app runs for the first time, otherwise false.</returns>
    public static bool IsFirstRun()
    {
        if (!settings.Contains(FIRST_RUN_FLAG)) //First time running
        {
            settings.Add(FIRST_RUN_FLAG, false);
            return true;
        }
        return false;   
    }

    public void loadModel()
    {
        string dataFromAppSettings;
        ContactLensesModel model;

        //Search for the string into the Application Settings
        if (IsolatedStorageSettings.ApplicationSettings.TryGetValue(MainPage.Model.modelKey, out dataFromAppSettings))
        {
            model = JsonConvert.DeserializeObject<ContactLensesModel>(dataFromAppSettings);
            MainPage.Model = model;
        }
        else //The model does not exist
        {
            MainPage.Model = null;

        }
    }

    public void saveModel()
    {
        //Convert to a JSON format
        var modelData = JsonConvert.SerializeObject(MainPage.Model);

        //Save the model to the settings
        IsolatedStorageSettings.ApplicationSettings[MainPage.Model.modelKey] = modelData;
        IsolatedStorageSettings.ApplicationSettings.Save();
    }

    /// <summary>
    /// Constructor for the Application object.
    /// </summary>
    public App()
    {
        // Global handler for uncaught exceptions.
        UnhandledException += Application_UnhandledException;

        // Standard XAML initialization
        InitializeComponent();

        // Phone-specific initialization
        InitializePhoneApplication();

        // Language display initialization
        InitializeLanguage();

        // Show graphics profiling information while debugging.
        if (Debugger.IsAttached)
        {
            // Display the current frame rate counters.
            Application.Current.Host.Settings.EnableFrameRateCounter = true;

            // Show the areas of the app that are being redrawn in each frame.
            //Application.Current.Host.Settings.EnableRedrawRegions = true;

            // Enable non-production analysis visualization mode,
            // which shows areas of a page that are handed off to GPU with a colored overlay.
            //Application.Current.Host.Settings.EnableCacheVisualization = true;

            // Prevent the screen from turning off while under the debugger by disabling
            // the application's idle detection.
            // Caution:- Use this under debug mode only. Application that disables user idle detection will continue to run
            // and consume battery power when the user is not using the phone.
            PhoneApplicationService.Current.UserIdleDetectionMode = IdleDetectionMode.Disabled;
        }

    }

    // Code to execute when the application is launching (eg, from Start)
    // This code will not execute when the application is reactivated
    private void Application_Launching(object sender, LaunchingEventArgs e)
    {
        RootFrame.UriMapper = new FirstRunUriMapper();
        loadModel();
    }

    // Code to execute when the application is activated (brought to foreground)
    // This code will not execute when the application is first launched
    private void Application_Activated(object sender, ActivatedEventArgs e)
    {
        loadModel();
        if (e.IsApplicationInstancePreserved == false)
        {
            RootFrame.UriMapper = new FirstRunUriMapper();

        }
    }

    // Code to execute when the application is deactivated (sent to background)
    // This code will not execute when the application is closing
    private void Application_Deactivated(object sender, DeactivatedEventArgs e)
    {
        saveModel();
    }

    // Code to execute when the application is closing (eg, user hit Back)
    // This code will not execute when the application is deactivated
    private void Application_Closing(object sender, ClosingEventArgs e)
    {
        saveModel();
    }

    // Code to execute if a navigation fails
    private void RootFrame_NavigationFailed(object sender, NavigationFailedEventArgs e)
    {
        if (Debugger.IsAttached)
        {
            // A navigation has failed; break into the debugger
            Debugger.Break();
        }
    }

    // Code to execute on Unhandled Exceptions
    private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
    {
        if (Debugger.IsAttached)
        {
            // An unhandled exception has occurred; break into the debugger
            Debugger.Break();
        }
    }

    #region Phone application initialization

    // Avoid double-initialization
    private bool phoneApplicationInitialized = false;

    // Do not add any additional code to this method
    private void InitializePhoneApplication()
    {
        if (phoneApplicationInitialized)
            return;

        // Create the frame but don't set it as RootVisual yet; this allows the splash
        // screen to remain active until the application is ready to render.
        RootFrame = new PhoneApplicationFrame();
        RootFrame.Navigated += CompleteInitializePhoneApplication;

        // Handle navigation failures
        RootFrame.NavigationFailed += RootFrame_NavigationFailed;

        // Handle reset requests for clearing the backstack
        RootFrame.Navigated += CheckForResetNavigation;

        // Ensure we don't initialize again
        phoneApplicationInitialized = true;
    }

    // Do not add any additional code to this method
    private void CompleteInitializePhoneApplication(object sender, NavigationEventArgs e)
    {
        // Set the root visual to allow the application to render
        if (RootVisual != RootFrame)
            RootVisual = RootFrame;

        // Remove this handler since it is no longer needed
        RootFrame.Navigated -= CompleteInitializePhoneApplication;
    }

    private void CheckForResetNavigation(object sender, NavigationEventArgs e)
    {
        // If the app has received a 'reset' navigation, then we need to check
        // on the next navigation to see if the page stack should be reset
        if (e.NavigationMode == NavigationMode.Reset)
            RootFrame.Navigated += ClearBackStackAfterReset;
    }

    private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
    {
        // Unregister the event so it doesn't get called again
        RootFrame.Navigated -= ClearBackStackAfterReset;

        // Only clear the stack for 'new' (forward) and 'refresh' navigations
        if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
            return;

        // For UI consistency, clear the entire page stack
        while (RootFrame.RemoveBackEntry() != null)
        {
            ; // do nothing
        }
    }

    #endregion

    // Initialize the app's font and flow direction as defined in its localized resource strings.
    //
    // To ensure that the font of your application is aligned with its supported languages and that the
    // FlowDirection for each of those languages follows its traditional direction, ResourceLanguage
    // and ResourceFlowDirection should be initialized in each resx file to match these values with that
    // file's culture. For example:
    //
    // AppResources.es-ES.resx
    //    ResourceLanguage's value should be "es-ES"
    //    ResourceFlowDirection's value should be "LeftToRight"
    //
    // AppResources.ar-SA.resx
    //     ResourceLanguage's value should be "ar-SA"
    //     ResourceFlowDirection's value should be "RightToLeft"
    //
    // For more info on localizing Windows Phone apps see http://go.microsoft.com/fwlink/?LinkId=262072.
    //
    private void InitializeLanguage()
    {
        try
        {
            // Set the font to match the display language defined by the
            // ResourceLanguage resource string for each supported language.
            //
            // Fall back to the font of the neutral language if the Display
            // language of the phone is not supported.
            //
            // If a compiler error is hit then ResourceLanguage is missing from
            // the resource file.
            RootFrame.Language = XmlLanguage.GetLanguage(AppResources.ResourceLanguage);

            // Set the FlowDirection of all elements under the root frame based
            // on the ResourceFlowDirection resource string for each
            // supported language.
            //
            // If a compiler error is hit then ResourceFlowDirection is missing from
            // the resource file.
            FlowDirection flow = (FlowDirection)Enum.Parse(typeof(FlowDirection), AppResources.ResourceFlowDirection);
            RootFrame.FlowDirection = flow;
        }
        catch
        {
            // If an exception is caught here it is most likely due to either
            // ResourceLangauge not being correctly set to a supported language
            // code or ResourceFlowDirection is set to a value other than LeftToRight
            // or RightToLeft.

            if (Debugger.IsAttached)
            {
                Debugger.Break();
            }

            throw;
        }
    }

}

```

}