In this post, I will show you how to Built-In Logging In .NET Core. For an application, logging is very important to keep track of that application and keep it error-free.

In .NET Core, we don't need any third party logging; instead, we can use built-in logging whenever we want. This is very efficient in terms of code and performance. Now, develope a new .NET Core application and name it.

Step 1: Go to Package mManager View-->Other Windows--> Package manager Console  -->

Install-Package Microsoft.Extensions.Logging

Add Logging
Once  the extension's installed, we can add logging by adding ILogger<T> (custom logging) or ILoggerFactory. If we want to use ILoggerFactory, then we must create it using CreateLogger, to use logging add logging services under ConfigureServices. Moreover, we can use built-in logging with the other loggings (like Nlog) with very minimal code.
services.AddLogging(); 

Startup.cs
public class Startup 
    { 
        public Startup(IHostingEnvironment env) 
        { 
            var builder = new ConfigurationBuilder() 
                .SetBasePath(env.ContentRootPath) 
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) 
                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) 
                .AddEnvironmentVariables(); 
            Configuration = builder.Build(); 
        } 
 
        public IConfigurationRoot Configuration { get; } 
 
        // This method gets called by the runtime. Use this method to add services to the container. 
        public void ConfigureServices(IServiceCollection services) 
        { 
            // Add framework services. 
            services.AddMvc(); 
            services.AddLogging(); 
        } 
 
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. 
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) 
        { 
            loggerFactory.AddConsole(Configuration.GetSection("Logging")); 
            loggerFactory.AddDebug(); 
 
            if (env.IsDevelopment()) 
            { 
                app.UseDeveloperExceptionPage(); 
                app.UseBrowserLink(); 
            } 
            else 
            { 
                app.UseExceptionHandler("/Home/Error"); 
            } 
 
            app.UseStaticFiles(); 
 
            app.UseMvc(routes => 
            { 
                routes.MapRoute( 
                    name: "default", 
                    template: "{controller=Home}/{action=Index}/{id?}"); 
            }); 
        } 
    } 

ILoggerFactory: We can use  ILoggerFactory. For this, we must use CreateLogger.

_logger = Mylogger.CreateLogger(typeof(HomeController)); 

HomeController.cs
public class HomeController : Controller 
    { 
        private ILogger _logger; 
 
        public HomeController(ILoggerFactory Mylogger) 
        { 
            _logger = Mylogger.CreateLogger(typeof(HomeController)); 
        } 
 
        public IActionResult Index() 
        { 
            return View(); 
        } 
 
        public IActionResult About() 
        { 
            try 
            { 
                ViewData["Message"] = "Your application description page."; 
                _logger.LogInformation("About Page has been Accessed"); 
                return View(); 
            } 
            catch (System.Exception ex) 
            { 
                _logger.LogError("About: " + ex.Message); 
                throw; 
            } 
        } 
 
        public IActionResult Contact() 
        { 
            try 
            { 
                ViewData["Message"] = "Your contact page."; 
                _logger.LogInformation("Contact Page has been Accessed"); 
                return View(); 
            } 
            catch (System.Exception ex) 
            { 
                _logger.LogError("Contact: " + ex.Message); 
                throw; 
            } 
        } 
 
        public IActionResult Error() 
        { 
            return View(); 
        } 
    } 

Run and Test

LogLevel: We can add logging level by adding the level we want in appsettings.json.Trace

• Debug
• Information
• Warning
• Error
• Application failure or crashes         
  

In this post, you will learn how to upload a file without PostBack in ASP.NET. My main focus to write this blog is that, if you work with file upload control, the page requires full PostBack and if your file upload control is inside the update panel, you must specify your submit button in trigger, as shown below.

 <Triggers> 
    <asp:PostBackTrigger ControlID=""/> 
 </Triggers> 

This also causes the full PostBack problem. To remove this problem, use "Handler" in ASP. NET C#.

UploadFile.ashx Code

 using System; 
 using System.Web; 
 using System.IO; 
 using System.Web.SessionState; 
 public class UploadFile: IHttpHandler, IRequiresSessionState { 
     public void ProcessRequest(HttpContext context) { 
         string filedata = string.Empty; 
         if (context.Request.Files.Count > 0) { 
             HttpFileCollection files = context.Request.Files; 
             for (int i = 0; i < files.Count; i++) { 
                 HttpPostedFile file = files[i]; 
                 if (Path.GetExtension(file.FileName).ToLower() != ".jpg" && 
                     Path.GetExtension(file.FileName).ToLower() != ".png" && 
                     Path.GetExtension(file.FileName).ToLower() != ".gif" && 
                     Path.GetExtension(file.FileName).ToLower() != ".jpeg" && 
                     Path.GetExtension(file.FileName).ToLower() != ".pdf" 
                 ) { 
                     context.Response.ContentType = "text/plain"; 
                     context.Response.Write("Only jpg, png , gif, .jpeg, .pdf are allowed.!"); 
                     return; 
                 } 
                 decimal size = Math.Round(((decimal) file.ContentLength / (decimal) 1024), 2); 
                 if (size > 2048) { 
                     context.Response.ContentType = "text/plain"; 
                     context.Response.Write("File size should not exceed 2 MB.!"); 
                     return; 
                 } 
                 string fname; 
                 if (HttpContext.Current.Request.Browser.Browser.ToUpper() == "IE" || HttpContext.Current.Request.Browser.Browser.ToUpper() == "INTERNETEXPLORER") { 
                     string[] testfiles = file.FileName.Split(new char[] { 
                         '\\' 
                     }); 
                     fname = testfiles[testfiles.Length - 1]; 
                 } else { 
                     fname = file.FileName; 
                 } 
                 //here UploadFile is define my folder name , where files will be store. 
                 string uploaddir = System.Configuration.ConfigurationManager.AppSettings["UploadFile"]; 
                 filedata = Guid.NewGuid() + fname; 
                 fname = Path.Combine(context.Server.MapPath("~/" + uploaddir + "/"), filedata); 
                 file.SaveAs(fname); 
             } 
         } 
         context.Response.ContentType = "text/plain"; 
         context.Response.Write("File Uploaded Successfully:" + filedata + "!"); 
         //if you want to use file path in aspx.cs page , then assign it in to session 
         context.Session["PathImage"] = filedata; 
     } 
     public bool IsReusable { 
         get { 
             return false; 
         } 
     } 
 } 

web.config code

 <?xml version="1.0"?> 
 <!-- 
 For more information on how to configure your ASP.NET application, please visit 
 http://go.microsoft.com/fwlink/?LinkId=169433 
 --> 
 <configuration> 
     <system.web> 
         <compilation debug="true" targetFramework="4.0" /> 
     </system.web> 
     <appSettings> 
         <add key="Upload" value="UploadFile" /> 
     </appSettings> 
 </configuration> 

Default.aspx code

 <%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %> 
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN""http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
     <html xmlns="http://www.w3.org/1999/xhtml"> 
  
     <head runat="server"> 
         <title></title> 
         <%-- Should have internet connection for loading this file other wise inherit own js file for supporting js library--%> 
             <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script> 
             <script type="text/javascript"> 
                 function onupload() { 
                     $(function() { 
                         var fileUpload = $('#<%=FileUpload.ClientID%>').get(0); 
                         var files = fileUpload.files; 
                         var test = new FormData(); 
                         for (var i = 0; i < files.length; i++) { 
                             test.append(files[i].name, files[i]); 
                         } 
                         $.ajax({ 
                             url: "UploadFile.ashx", 
                             type: "POST", 
                             contentType: false, 
                             processData: false, 
                             data: test, 
                             success: function(result) { 
                                 if (result.split(':')[0] = "File Uploaded Successfully") { 
                                     document.getElementById("<%=lbl_smsg.ClientID%>").innerText = result.split(':')[0]; 
                                 } else { 
                                     document.getElementById("<%=lbl_emsg.ClientID%>").innerText = result; 
                                 } 
                             }, 
                             error: function(err) { 
                                 alert(err.statusText); 
                             } 
                         }); 
                     }) 
                 } 
             </script> 
     </head> 
  
     <body> 
         <form id="form1" runat="server"> 
             <asp:ScriptManager ID="scmain" runat="server"></asp:ScriptManager> 
             <asp:UpdatePanel ID="upmain" runat="server"> 
                 <ContentTemplate> 
                     <fieldset> 
                         <legend>Upload File WithOut PostBack inside Update Panel</legend> 
                         <asp:FileUpload ID="FileUpload" runat="server" /> 
                         <input type="button" id="btnUpload" value="Upload Files" onclick="onupload();" /> 
                         <asp:Label ID="lbl_emsg" runat="server" ForeColor="Red"></asp:Label> 
                         <asp:Label ID="lbl_smsg" runat="server" ForeColor="Green"></asp:Label> 
                     </fieldset> 
                 </ContentTemplate> 
             </asp:UpdatePanel> 
         </form> 
     </body> 
  
     </html> 

Default.aspx code.cs code

 using System; 
 using System.Collections.Generic; 
 using System.Linq; 
 using System.Web; 
 using System.Web.UI; 
 using System.Web.UI.WebControls; 
 public partial class _Default: System.Web.UI.Page 
 { 
     protected void Page_Load(object sender, EventArgs e) {} 
 } 

HostForLIFE.eu ASP.NET Core 1.1 Hosting

European best, cheap and reliable ASP.NET hosting with instant activation. HostForLIFE.eu is #1 Recommended Windows and ASP.NET hosting in European Continent. With 99.99% Uptime Guaranteed of Relibility, Stability and Performace. HostForLIFE.eu security team is constantly monitoring the entire network for unusual behaviour. We deliver hosting solution including Shared hosting, Cloud hosting, Reseller hosting, Dedicated Servers, and IT as Service for companies of all size.

When you build ASP.NET Core applications and you plan on running your applications on IIS you'll find that the way that Core applications work in IIS is radically different than in previous versions of ASP.NET.

In this post I'll explain how ASP.NET Core runs in the context of IIS and how you can deploy your ASP.NET Core application to IIS.

Setting Up Your IIS and ASP.NET Core

The most important thing to understand about hosting ASP.NET Core is that it runs as a standalone, out of process Console application. It's not hosted inside of IIS and it doesn't need IIS to run. ASP.NET Core applications have their own self-hosted Web server and process requests internally using this self-hosted server instance.

You can however run IIS as a front end proxy for ASP.NET Core applications, because Kestrel is a raw Web server that doesn't support all features a full server like IIS supports. This is actually a recommended practice on Windows in order to provide port 80/443 forwarding which kestrel doesn't support directly. For Windows IIS (or another reverse proxy) will continue to be an important part of the server even with ASP.NET Core applications.

Run Your ASP.NET Core Site

To run your ASP.NET Core site, it is quite different with your previous ASP.NET version. ASP.NET Core runs its own web server using Kestrel component. Kestrel is a .NET Web Server implementation that has been heavily optimized for throughput performance. It's fast and functional in getting network requests into your application, but it's 'just' a raw Web server. It does not include Web management services as a full featured server like IIS does.

If you run on Windows you will likely want to run Kestrel behind IIS to gain infrastructure features like port 80/443 forwarding via Host Headers, process lifetime management and certificate management to name a few.

ASP.NET Core applications are standalone Console applications invoked through the dotnet runtime command. They are not loaded into an IIS worker process, but rather loaded through a native IIS module called AspNetCoreModule that executes the external Console application.

Once you've installed the hosting bundle (or you install the .NET Core SDK on your Dev machine) the AspNetCoreModule is available in the IIS native module list:

The AspNetCoreModule is a native IIS module that hooks into the IIS pipeline very early in the request cycle and immediately redirects all traffic to the backend ASP.NET Core application. All requests - even those mapped to top level Handlers like ASPX bypass the IIS pipeline and are forwarded to the ASP.NET Core process. This means you can't easily mix ASP.NET Core and other frameworks in the same Site/Virtual directory, which feels a bit like a step back given that you could easily mix frameworks before in IIS.

While the IIS Site/Virtual still needs an IIS Application Pool to run in, the Application Pool should be set to use No Managed Code. Since the App Pool acts merely as a proxy to forward requests, there's no need to have it instantiate a .NET runtime.

The AspNetCoreModule's job is to ensure that your application gets loaded when the first request comes in and that the process stays loaded if for some reason the application crashes. You essentially get the same behavior as classic ASP.NET applications that are managed by WAS (Windows Activation Service).

Once running, incoming Http requests are handled by this module and then routed to your ASP.NET Core application.

So, requests come in from the Web and int the kernel mode http.sys driver which routes into IIS on the primary port (80) or SSL port (443). The request is then forwarded to your ASP.NET Core application on the HTTP port configured for your application which is not port 80/443. In essence, IIS acts a reverse proxy simply forwarding requests to your ASP.NET Core Web running the Kestrel Web server on a different port.

Kestrel picks up the request and pushes it into the ASP.NET Core middleware pipeline which then handles your request and passes it on to your application logic. The resulting HTTP output is then passed back to IIS which then pushes it back out over the Internet to the HTTP client that initiated the request - a browser, mobile client or application.

The AspNetCoreModule is configured via the web.config file found in the application's root, which points a the startup command (dotnet) and argument (your application's main dll) which are used to launch the .NET Core application. The configuration in the web.config file points the module at your application's root folder and the startup DLL that needs to be launched.

Here's what the web.config looks like:

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <!--
    Configure your application settings in appsettings.json. Learn more at http://go.microsoft.com/fwlink/?LinkId=786380
  -->
  <system.webServer>
    <handlers>
      <add name="aspNetCore" path="*" verb="*"
        modules="AspNetCoreModule" resourceType="Unspecified" />
    </handlers>
    <aspNetCore processPath="dotnet"
                arguments=".\AlbumViewerNetCore.dll"
                stdoutLogEnabled="false"
                stdoutLogFile=".\logs\stdout"
                forwardWindowsAuthToken="false" />
  </system.webServer>
</configuration>

You can see that module references dotnetexe and the compiled entry point DLL that holds your Main method in your .NET Core application.

IIS is Recommended!

We've already discussed that when running ASP.NET Core on Windows, it's recommended you use IIS as a front end proxy. While it's possible to directly access Kestrel via an IP Address and available port, there are number of reasons why you don't want to expose your application directly this way in production environments.

First and foremost, if you want to have multiple applications running on a single server that all share port 80 and port 443 you can't run Kestrel directly. Kestrel doesn't support host header routing which is required to allow multiple port 80 bindings on a single IP address. Without IIS (or http.sys actually) you currently can't do this using Kestrel alone (and I think this is not planned either).

The AspNetCoreModule running through IIS also provides the necessary process management to ensure that your application gets loaded on the first access, ensures that it stays up and running and is restarted if it crashes. The AspNetCoreModule provides the required process management to ensure that your AspNetCore application is always available even after a crash.

It's also a good idea to run secure SSL requests through IIS proper by setting up certificates through the IIS certificate store and letting IIS handle the SSL authentication. The backplane HTTP request from IIS can then simply fire a non-secure HTTP request to your application. This means only a the front end IIS server needs a certificate even if you have multiple servers on the backplane serving the actual HTTP content.

IIS can also provide static file serving, gzip compression of static content, static file caching, Url Rewriting and a host of other features that IIS provides natively. IIS is really good and efficient at processing non-application requests, so it's worthwhile to take advantage of that. You can let IIS handle the tasks that it's really good at, and leave the dynamic tasks to pass through to your ASP.NET Core application.

The bottom line for all of this is if you are hosting on Windows you'll want to use IIS and the AspNetCoreModule.

How to Publish ASP.NET Core in IIS

In order to run an application with IIS you have to first publish it. There are two ways to that you can do this today:

1. Use dotnet publish

Using dotnet publish builds your application and copies a runnable, self-contained version of the project to a new location on disk. You specify an output folder where all the files are published. This is not so different from classic ASP.NET which ran Web sites out of temp folders. With ASP.NET Core you explicitly publish an application into a location of your choice - the files are no longer hidden away and magically copied around.

A typical publish command may look like this:

dotnet publish
      --framework netcoreapp1.0
      --output "c:\temp\AlbumViewerWeb"
      --configuration Release

If you open this folder you'll find that it contains your original application structure plus all the nuget dependency assemblies dumped into the root folder:

Once you've published your application and you've moved it to your server (via FTP or other mechanism) we can then hook up IIS to the folder.

After that, please just make sure you setup .NET Runtime to No Managed Code as shown above.

And that's really all that needs to happen. You should be able to now navigate to your site or Virtual and the application just runs.

You can now take this locally deployed Web site, copy it to a Web Server (via FTP or direct file copy or other publishing solution), set up a Site or Virtual and you are off to the races.

2. Publish Using Visual Studio

The dotnet publish step works to copy the entire project to a folder, but it doesn't actually publish your project to a Web site (currently - this is likely coming at a later point).

In order to get incremental publishing to work, which is really quite crucial for ASP.NET Core applications because there are so many dependencies, you need to use MsDeploy which is available as part of Visual Studio's Web Publishing features.

Currently the Visual Studio Tooling UI is very incomplete, but the underlying functionality is supported. I'll point out a few tweaks that you can use to get this to work today.

When you go into Visual Studio in the RC2 Web tooling and the Publish dialog, you'll find that you can't create a publish profile that points at IIS. There are options for file and Azure publishing but there's no way through the UI to create a new Web site publish.

However, you can cheat by creating your own .pubxml file and putting it into the \Properties\PublishProfilesfolder in your project.

To create a 'manual profile' in your ASP.NET Core Web project:

• Create a folder \Properties\PublishProfiles
• Create a file <MyProfile>.pubxml

You can copy an existing .pubxml from a non-ASP.NET Core project or create one. Here's an example of a profile that works with IIS:

<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <WebPublishMethod>MSDeploy</WebPublishMethod>
    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
    <LastUsedPlatform>Any CPU</LastUsedPlatform>
    <SiteUrlToLaunchAfterPublish>http://samples.west-wind.com/AlbumViewerCore/index.html</SiteUrlToLaunchAfterPublish>
    <LaunchSiteAfterPublish>True</LaunchSiteAfterPublish>
    <ExcludeApp_Data>False</ExcludeApp_Data>
    <PublishFramework>netcoreapp1.0</PublishFramework>
    <UsePowerShell>True</UsePowerShell>
    <EnableMSDeployAppOffline>True</EnableMSDeployAppOffline>
    <MSDeployServiceURL>https://publish.west-wind.com</MSDeployServiceURL>
    <DeployIisAppPath>samples site/albumviewercore</DeployIisAppPath>
    <RemoteSitePhysicalPath />
    <SkipExtraFilesOnServer>True</SkipExtraFilesOnServer>
    <MSDeployPublishMethod>RemoteAgent</MSDeployPublishMethod>
    <EnableMSDeployBackup>False</EnableMSDeployBackup>
    <UserName>username</UserName>
    <_SavePWD>True</_SavePWD>
    <ADUsesOwinOrOpenIdConnect>False</ADUsesOwinOrOpenIdConnect>
    <AuthType>NTLM</AuthType>
  </PropertyGroup>
</Project>

Once you've created a .pubxml file you can now open the publish dialog in Visual Studio with this Profile selected:

At this point you should be able to publish your site to IIS on a remote server and use incremental updates with your content.

#And it's a Wrap Currently IIS hosting and publishing is not particularly well documented and there are some rough edges around the publishing process. Microsoft knows of these issues and this will get fixed by RTM of ASP.NET Core.

In the meantime I hope this post has provided the information you need to understand how IIS hosting works and a few tweaks that let you use the publishing tools available to get your IIS applications running on your Windows Server.