{"id":35132,"date":"2018-04-04T14:38:59","date_gmt":"2018-04-04T21:38:59","guid":{"rendered":"https:\/\/blog.xamarin.com\/?p=35132"},"modified":"2019-04-04T08:34:59","modified_gmt":"2019-04-04T15:34:59","slug":"debugging-xamarin-mono","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/xamarin\/debugging-xamarin-mono\/","title":{"rendered":"Debugging Xamarin Open Source Frameworks: Part 3 – Mono"},"content":{"rendered":"

\t\t\t\tThis is the third post of four in the Debugging Xamarin Open Source Frameworks series, debugging Mono. Part 1<\/a> covers building Xamarin.Forms from the source and debugging that code, Part 2<\/a> covers Xamarin.iOS, and Part 4 steps into the source code to build and debug Xamarin.Android.<\/p>\n

Debugging in Mono<\/h2>\n

If you work with Xamarin to develop awesome mobile apps, at some point you may have received an exception or error from the Mono runtime or BCL (Base Class Library). You may have wanted to step through that code to see if the error is something you can resolve, or if it’s a bug in the Mono code. You might even have wanted to file a pull request to merge a fix into the framework itself. Since Mono and the Xamarin frameworks (i.e. Xamarin.iOS, Xamarin.Android, and Xamarin.Forms) are all open source, this post will show you how you can help contribute to debugging!<\/p>\n

For this post, a Mac computer will be used to build Mono from the source code<\/em><\/a>. You can also use Windows<\/em><\/a> or Linux<\/em><\/a>.<\/em><\/p>\n

Getting the Mono source code<\/h3>\n

There are a number of ways to get the Mono source code. The official Mono repository on GitHub is located at: https:\/\/github.com\/mono\/mono<\/a>. If you’re already familiar with using git and GitHub, you can get the source code using your preferred method and skip to the next section.<\/p>\n

Use your Github account to fork the Mono repository and then clone that fork to your computer. If you do not have a GitHub account, just clone the official Mono repository directly to your computer.<\/p>\n

In the Mono repository linked above, you can fork the official repository to your own GitHub repository by hitting the Fork<\/strong> button in the upper right, which will create a new repository under your account:\n\"\"<\/p>\n

Whether you fork the repository or not, you can just select the Clone<\/strong> or download<\/strong> button, either in your fork or on the official Xamarin.iOS repo. Clicking the Clone or download<\/strong> button gives you two options:<\/p>\n

    \n
  1. Open in Desktop<\/strong>: Opens the GitHub Desktop app<\/a> on your Mac (get it here<\/a>) and clone the repository to the directory that you specify:\n
      \n
    1. Make commits<\/li>\n
    2. Start pull requests<\/li>\n
    3. Switch branches using the GitHub Desktop app, no command line necessary.<\/li>\n<\/ol>\n

      Note:<\/strong> only the master branch on GitHub will be downloaded. On the GitHub Desktop, you can switch branches and then that branch will be downloaded onto your computer as well (this may take some time).<\/em><\/li>\n

    4. Download ZIP<\/strong>: Downloads the currently selected branch as a .zip file. When you unzip, you will note that this is not a GIT repository, so it isn’t ready to do commits, pull requests, switch branches, etc. If you only want to work with one specific branch, this may be the right option for you.<\/li>\n<\/ol>\n

      Building Mono Dependencies<\/h3>\n

      Once you have the source downloaded to your machine, use these instructions<\/a> as a guide to build Mono on your Mac, with some caveats noted below. It is recommended to read this entire section before starting.<\/p>\n

      By default, you build the master branch of Mono. Verify that the master branch is building successfully by checking the Build Status<\/strong><\/a> OS X section on the main page of the GitHub repository. If OS X shows as failing<\/em> or unstable<\/em>, get a different branch to build.<\/p>\n

      In the Building Mono Dependencies<\/em><\/a> section of the instructions linked above, you’ll see a reference to Homebrew<\/em><\/a>, a macOS package manager. Get it here<\/a> to install dependencies like autoconf<\/strong> and cmake<\/strong>.<\/p>\n

      Build and Install Mono<\/h2>\n

      Once you’re done installing your Mono dependencies, you’re ready to build and install Mono using the instructions for Building Mono From a Git Source Code Checkout<\/em><\/a>. It’s important to set the PREFIX<\/strong>, which will be the path for your Mono install. Use \/usr\/local<\/strong>, as in the build instructions for a release package<\/a>.<\/p>\n

      In this case the Mono repo is at path:<\/p>\n

      \/Users\/\/git\/mono<\/code><\/pre>\n
      Create the following folder for the Mono install:<\/p>\n
      \/Users\/\/git\/mono-install<\/code><\/pre>\n
      We do not need to run the git clone …<\/strong> command since the repository is already cloned. Instead, do the following:<\/p>\n
        \n
      1. Open Terminal and navigate to your Mono repository (replace \/path\/to\/mono<\/strong> with the actual path to your Mono repository):\n
        cd \/path\/to\/mono<\/pre>\n
        <\/code><\/li>\n
      2. Set the PREFIX<\/strong> variable (replace \/path\/to\/mono-install<\/strong> with the actual path to your Mono install folder):\n
        PREFIX=\/path\/to\/mono-install<\/pre>\n
        <\/code><\/li>\n
      3. Add PREFIX\/bin<\/strong> to your $PATH<\/strong> variable:\n
        PATH=$PREFIX\/bin:$PATH<\/pre>\n
        <\/code><\/li>\n
      4. Run the following commands to build in 64 bit mode:\n
        .\/autogen.sh --prefix=$PREFIX --disable-nls<\/pre>\n
        <\/code><\/p>\n
          \n
        1. Make<\/li>\n
        2. Make install<\/li>\n<\/ol>\n<\/ol>\n
          Congratulations, you have now successfully built Mono! See the troubleshooting<\/a> section for any possible issues.<\/p>\n
          Bring Mono to Visual Studio for Mac<\/h2>\n
          There are a couple of things to do in Visual Studio for Mac to make your shiny new Mono build available and start stepping into the Mono source code:<\/p>\n
            \n
          1. Open Visual Studio for Mac.<\/li>\n
          2. Open Visual Studio > Preferences<\/strong>.<\/li>\n
          3. Select Projects > Debugger<\/strong> on the left.<\/li>\n
          4. Uncheck \"Debug project code only; do not step into framework code\"<\/strong>.\n
            \"\"<\/li>\n
          5. Select Projects > .NET Runtimes<\/strong> on the left.<\/li>\n
          6. Click the Add<\/strong> button.<\/li>\n
          7. Browse to the folder where you installed Mono earlier.<\/li>\n
          8. Select and Open<\/strong>.<\/li>\n
            \"\"<\/li>\n<\/ol>\n
            Once you have a solution loaded, select your new build of Mono using the Project > Active Runtime<\/strong> menu. You can now step into the Mono source code while debugging.<\/p>\n
            Debugging Mono Source Code<\/h2>\n
              \n
            1. Open Visual Studio for Mac.<\/li>\n
            2. Create a new .NET Console project (File > New Solution > Other > .NET > Console Project<\/strong>).\n
              \"\"<\/li>\n
            3. Select the Mono runtime you just built as the active runtime:\na. Select menu Project > Active Runtime.<\/strong>\nb. You will see your Mono runtime along with others installed on the system. Select the runtime that matches the path where Mono is installed.<\/p>\n
              \"\"<\/li>\n
            4. By default, MSBuild<\/strong> is not included<\/strong> when building mono from source. Use xbuild<\/strong> instead of MSBuild<\/strong> for this console project:\na. Right click on the console project in the solution explorer and select Options<\/strong>.\nb. Select Build > General<\/strong> on the left.\nc. Uncheck the Use MSBuild build engine...<\/strong> option.<\/p>\n
              \"\"<\/li>\n
            5. Open the Program.cs<\/strong> file.<\/li>\n
            6. Place a breakpoint on the Console.WriteLine<\/strong> statement.<\/li>\n
            7. Run the project with debugging.<\/li>\n
            8. When the program pauses on the Console.WriteLine<\/strong> statement, step into the code.<\/li>\n<\/ol>\n
              \"\"<\/p>\n
              Congratulations, you're now stepping into and through Mono source code! Right click on the tab for the Mono source code file that opens in Visual Studio for Mac, and select Reveal in Finder<\/strong>.<\/p>\n
              \"\"<\/p>\n
              A Finder window will open with the source code file highlighted so you can see that this is the source code file from your cloned Mono repository. Assuming you cloned the repo instead of downloading a .zip archive, you can also edit the code and make a new commit or pull request using GitHub Desktop.<\/p>\n
              Summary<\/h2>\n
              Through this post, you now have the ability to use, build, and install Mono from source code onto your computer. Additionally, you learned how to make your build of Mono available to Visual Studio for Mac and use it in a Console project to step into and through the Mono source code. <\/p>\n
              If you fixed a bug or made some improvement during this process that you would like to share, please contribute to debugging Mono<\/a>.<\/p>\n
              Enjoy this post? Discuss it on the forums<\/a>!\t\t<\/p>\n","protected":false},"excerpt":{"rendered":"
              This is the third post of four in the Debugging Xamarin Open Source Frameworks series, debugging Mono. Part 1 covers building Xamarin.Forms from the source and debugging that code, Part 2 covers Xamarin.iOS, and Part 4 steps into the source code to build and debug Xamarin.Android. Debugging in Mono If you work with Xamarin to […]<\/p>\n","protected":false},"author":554,"featured_media":39167,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2],"tags":[4],"class_list":["post-35132","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-developers","tag-xamarin-platform"],"acf":[],"blog_post_summary":"
              This is the third post of four in the Debugging Xamarin Open Source Frameworks series, debugging Mono. Part 1 covers building Xamarin.Forms from the source and debugging that code, Part 2 covers Xamarin.iOS, and Part 4 steps into the source code to build and debug Xamarin.Android. Debugging in Mono If you work with Xamarin to […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts\/35132","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/users\/554"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/comments?post=35132"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts\/35132\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/media\/39167"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/media?parent=35132"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/categories?post=35132"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/tags?post=35132"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}