{"id":3364,"date":"2009-10-29T16:49:00","date_gmt":"2009-10-29T16:49:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/webdev\/2009\/10\/29\/converting-a-web-site-project-to-a-web-application-project\/"},"modified":"2009-10-29T16:49:00","modified_gmt":"2009-10-29T16:49:00","slug":"converting-a-web-site-project-to-a-web-application-project","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/converting-a-web-site-project-to-a-web-application-project\/","title":{"rendered":"Converting a Web Site Project to a Web Application Project"},"content":{"rendered":"

Differences between Web Site Projects (WSP) and Web Application Projects (WAP) are highlighted in blogs such as this one<\/A>. Based on that, if you feel a WAP would be better for your particular needs than a WSP, but have already created a WSP, you may be asking yourself, \u201cCan I convert my WSP into a WAP, without starting from scratch?\u201d.<\/P>\n

This posting explains how to convert an existing Web Site Project to a Web Application Project in Visual Studio 2010. The most striking differences to a Web Site Project are that WAPs have a project file to include and exclude files, and compile to a single assembly.<\/P>\n

The guidelines below include several of the basic steps detailed in the Walkthrough: Converting a Web Site Project to a Web Application Project in Visual Studio<\/A>. This is an excellent topic to review as it discusses some specific issues you may encounter which were discovered in previous versions of Visual Studio (VS). Please keep in mind while reading it that it is based on a WSP to WAP conversion using previous versions of Visual Studio.<\/P>\n

Let\u2019s get started.<\/P>\n

Open and Verify your Visual Studio Web Site Project<\/FONT><\/STRONG>
Before converting your WSP to a WAP, you should open it in Visual Studio and verify that is it working correctly.  This will help prevent the need to research errors that have nothing to do with the conversion process.<\/P>\n

    \n
  1. In the File<\/STRONG> menu, click Open Web Site<\/STRONG>. <\/LI>\n
  2. The Open Web Site<\/B> dialog box is displayed. <\/LI>\n
  3. Select the project folder that you want to open, and then click Open<\/B>. <\/LI>\n
  4. In the Build<\/B> menu, click Build Web Site<\/B>. <\/LI>\n
  5. In the Debug<\/B> menu, click Start Debugging<\/B>. Alternatively, you can press F5. <\/LI>\n
  6. Verify your project compiles and runs as expected <\/LI><\/OL>\n

    Create a new, empty Visual Studio WAP
    <\/FONT><\/STRONG>A good strategy for converting a WSP to a WAP is to create a new, blank Visual Studio Web Application Project in a separate directory, but in the same solution. This avoids changing any part of the existing Web site files. It also allows you to copy existing functionality and files into the new WAP easily, within the same Visual Studio instance.<\/P>\n

      \n
    1. In the File<\/B> menu, click Add<\/B>, and then click New <\/B>Project<\/B>. <\/LI>\n
    2. The Add <\/B>New Project<\/B> dialog box is displayed. <\/LI>\n
    3. In the Installed Templates<\/B> section of the Add <\/B>New Project<\/B> dialog box, expand the language that you want to use, and then select Web<\/B> to display the Web-related templates. <\/LI>\n
    4. Select Empty <\/B>ASP.NET Web Application<\/B>. <\/LI>\n
    5. Type values for Name<\/B>, Location,<\/B> and then click OK<\/B> to create the Web Application Project. <\/LI>\n
    6. After the project has been created, delete the Web.config file that is created automatically. <\/LI><\/OL>\n
      \n

      \"WSPandWAP\"<\/A> <\/P><\/BLOCKQUOTE>\n

      Set Project \/ Assembly References<\/FONT><\/STRONG>
      If the WSP required additional project or assembly references, you need to add them to the WAP. You can see the list of default references associated with the new (empty) Visual Studio Web Application Project under the References node in Solution Explorer.<\/P>\n

        \n
      1. In the Solution Explorer<\/STRONG>, make sure Show All Files<\/B> is turned on. <\/LI>\n
      2. In the Solution Explorer<\/B>, right-click References<\/STRONG>, and then click Add Reference<\/STRONG>. <\/LI>\n
      3. The Add Reference<\/STRONG> dialog box is displayed. <\/LI>\n
      4. Select the reference that you have already added in the Web Site Project and then click OK. <\/LI>\n
      5. Note: To help prevent errors, add references to the Web Application Project for assemblies that existed in the \\bin folder of the WSP. <\/LI><\/OL>\n
        \n

        \"AddRef\"<\/A> <\/P><\/BLOCKQUOTE>\n

        Copy and Convert the App_Code folder from the Web Site Project to the Web Application Project<\/FONT><\/STRONG>
        In WSPs, the files in the App_Code folder are all compiled together and then referenced (automatically) as a \u201cdll\u201d by all other files in the WSP. In WAPs, this is not the case. All code is compiled together as one .dll. I\u2019ve found that copying the App_Code folder over first and converting it to the WAP model helps to head off some dependency issues which could arise if one copied the entire site, converted, and then tried to compile.<\/P>\n

          \n
        1. In the Solution Explorer<\/STRONG>, copy the entire App_Code<\/STRONG> folder from the WSP to the WAP <\/LI>\n
        2. In the Solution Explorer<\/STRONG>, select the WAP\u2019s root node<\/U>; right-click, select Convert to Web Application<\/STRONG> <\/LI>\n
        3. You will see our standard Convert to Web Application confirmation dialog.  Select \u201cYes\u201d to this dialog. <\/LI>\n
        4. The App_Code<\/STRONG> folder should now be renamed to Old_App_Code<\/STRONG> folder <\/LI>\n
        5. Note:<\/U> Do NOT name it back. As mentioned above, in the WAP model all code will be compiled into one assembly. At runtime, ASP.NET doesn\u2019t know what type of project model you have created and will take anything in the \u201cApp_Code\u201d folder and create a dynamic assembly for it, thereby causing \u201ccould not load type\u201d exceptions as there would be duplicate types exists in two assemblies (the one for the VS web application and the one for App_Code).  Learn more about why App_Code folder does not work well with WAPs<\/A>. <\/LI>\n
        6. Compile the WAP <\/LI>\n
        7. If you see an error, the most likely causes are: \n
            \n
          1. Missing assembly reference. See the section above to add missing references to your project. <\/LI>\n
          2. Files marked with Build Action = Content instead of Build Action = Compile. Any file you want compiled should be marked as such. <\/LI>\n
          3. To set the Build Action property: \n
              \n
            1. Select the file in the Solution Explorer<\/STRONG> <\/LI>\n
            2. Press F4 (Brings up the File\u2019s Property Grid) <\/LI>\n
            3. Look at the Build Action property. Change as necessary. <\/LI><\/OL><\/LI><\/OL><\/LI><\/OL>\n
              \n

              \"converttowap\"<\/A> <\/P><\/BLOCKQUOTE>\n

              Copy and Convert the remaining Files and Folders from the WSP to the WAP<\/FONT><\/STRONG>
              Once your Old_App_Code folder is compiled (by compiling your WAP in the step above), your WAP will have an assembly in the \\bin directory. This will make it easier for the remaining files you are copying over to successfully compile, especially if they reference or use code in the files contained within that folder.<\/P>\n

                \n
              1. Select the remaining files \/ folders from the WSP project and copy them into the WAP. <\/LI>\n
              2. Make sure not to copy the App_Code<\/STRONG> folder again. <\/LI>\n
              3. In the Solution Explorer<\/STRONG>, right click the root node of the WAP and select Convert to Web Application<\/STRONG>. \n
                  \n
                1. Don\u2019t worry, this won\u2019t affect (or try to reconvert) any files or the Old_App_Code folder you have already converted. <\/LI><\/OL><\/LI>\n
                2. Note:<\/U> This will cause VS to automatically generate a .designer.cs (or .vb) file for each page, user-control, and master page in the project. Additionally, each .aspx\/.ascx will be modified to use the \u2018Codebehind\u2019 instead of the \u2018CodeFile\u2019 attribute in the Page directive. \n
                    \n
                  1. Example of the \u2018CodeFile\u2019 to \u2018Codebehind\u2019 change \n
                      \n
                    1. WSP file:  <%@ Page Title=\u201dHome Page\u201d Language=\u201dC#\u201d CodeFile=\u201dDefault.aspx.cs\u201d Inherits=\u201d_Default\u201d %><\/FONT> <\/LI>\n
                    2. Converted WAP file:  <%@ Page Title=\u201dHome Page\u201d Language=\u201dC#\u201d Inherits=\u201d_Default\u201d Codebehind=\u201dDefault.aspx.cs\u201d %><\/FONT> <\/LI><\/OL><\/LI><\/OL><\/LI><\/OL>\n
                      \n

                      \"convertedfiles\"<\/A> <\/P><\/BLOCKQUOTE>\n

                      Compile your WAP
                      <\/FONT><\/STRONG>After all the files have been added and converted, you should build your project again to see if there are any compilation errors. At this point, some of the most likely causes of errors are:<\/P>\n

                        \n
                      1. Code files set with Build Action = Content. These should be changed to Compile. Refer to the above section. <\/LI>\n
                      2. Missing project or assembly references. See above for steps for adding project or assembly references. <\/LI>\n
                      3. Class name collisions. In the WSP model, each .aspx and associated codefile was compiled together as a separate, individual unit. Therefore, one could have files such as foo\\widget.ascx.cs and bar\\widget.ascx.cs where the classes were the same. Once these files are moved to a WAP and all compiled together, class name collisions occur with errors something like, \u201chas multiple definitions with identical signatures\u201d. If this occurs, unique class names should be created. <\/LI><\/OL>\n

                        Run your WAP<\/FONT><\/STRONG>
                        After completing the above steps and you have a WAP which successfully compiles, you are ready to try running your application. One of the most common problems I\u2019ve seen encountered is the \u201cUnknown server tag \u2018SomeTag: Control\u2019 (as it applies to user controls and such)\u201d. This can be corrected in one of two ways.<\/P>\n

                          \n
                        1. Add or modify the register directive on the page that is using the control. This will only register it for this specific page. \n
                            \n
                          1. <%@ Register Namespace\u201dnamespace the control is in\u201d TagPrefix=\u201dSomeTag\u201d Assembly=\u201dName of dll compiled into the \\bin folder\u201d %><\/FONT> <\/LI><\/OL><\/LI>\n
                          2. Register the control in the Web.config, making it available to all pages in the project \n
                              \n
                            1. In the <pages><controls> section add the following: <\/LI>\n
                            2. <add tagPrefix=\u201dSomeTag\u201d namespace=\u201dnamespace the control is in\u201d assembly=\u201d Name of dll compiled into the \\bin folder\u201d \/><\/FONT> <\/LI><\/OL><\/LI><\/OL>\n

                              Hope this helps!<\/P>\n


                              Nichole Baker
                              SDET, Visual Studio Web Tools<\/P><\/p>\n","protected":false},"excerpt":{"rendered":"

                              Differences between Web Site Projects (WSP) and Web Application Projects (WAP) are highlighted in blogs such as this one. Based on that, if you feel a WAP would be better for your particular needs than a WSP, but have already created a WSP, you may be asking yourself, \u201cCan I convert my WSP into a […]<\/p>\n","protected":false},"author":404,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[197],"tags":[147,7302,7323,7319,7292,7264],"class_list":["post-3364","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-aspnet","tag-visual-studio","tag-visual-studio-2008","tag-visual-studio-2010","tag-visual-web-developer","tag-vs2008","tag-wap"],"acf":[],"blog_post_summary":"

                              Differences between Web Site Projects (WSP) and Web Application Projects (WAP) are highlighted in blogs such as this one. Based on that, if you feel a WAP would be better for your particular needs than a WSP, but have already created a WSP, you may be asking yourself, \u201cCan I convert my WSP into a […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/3364","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/404"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=3364"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/3364\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=3364"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=3364"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=3364"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}