ASP.NET Core 1.0 – Enable Minification

To enable minification, ensure the following:
1. Config.asax, register the BundlesConfig
protected void Application_Start()

{
         BundlesConfig.RegisterBundles(BundleTable.Bundles);
}

2. BundleConfig.cs, include the scripts and enable optimizations
public static void RegisterBundles(BundleCollection bundles)

{
  bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
    "~/Scripts/jquery-{version}.js"));
BundleTable.EnableOptimizations = true;
}

3. main.html, register the scripts

@section scripts {
       @Scripts.Render("~/bundles/jquery")
}

4. In addition the minification process changes $scope and $q into random variables. Since this does nto tell angular what to inject, the solution is to declare your dependencies wrapped in []:
angular.module("MyApp")

       .controller("MyCtrl", ["$scope", "$q", function($scope, $q) {
  // your code
}])

 

This is just the steps you need to enable minification.

Advertisements

Include WebAPI to an existent project with ASP.NET MVC

If you have a new project and wan’t to create a project with MVC and WebAPI together, you just need to select the correct template on Visual Studio.
But and if you already have an MVC project and wan’t to include an WebAPI on the same project. How can you do that?

1. Add reference to 
System.Web.Http.WebHost.
2. Add App_Start\WebApiConfig.cs (see code snippet below).
3. Import namespace System.Web.Http in Global.asax.cs.
4. Call WebApiConfig.Register(GlobalConfiguration.Configuration) in MvcApplication.Application_Start() (in file Global.asax.cs), before registering the default Web Application route as that would otherwise take precedence.
5. Add a controller deriving from System.Web.Http.ApiController.


I could then learn enough from 
the tutorial  (Your First ASP.NET Web API) to define my API controller.

App_Start\WebApiConfig.cs:

using System.Web.Http;
class WebApiConfig
{
    public static void Register(HttpConfiguration configuration)
    {
        configuration.Routes.MapHttpRoute("API Default", "api/{controller}/{id}",
            new { id = RouteParameter.Optional });
    }
}

Global.asax.cs:

using System.Web.Http;
...
protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
    WebApiConfig.Register(GlobalConfiguration.Configuration);
    RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);
}


The NuGet package Microsoft.AspNet.WebApi must be installed for the above to work.

ASP.NET Core 1.0 – Configure Application Insights

This article will show how to integrate Microsoft Azure Application .Insights into a web application using ASP.NET Core 1.0 to Detect, triage, and diagnose issues in your web application

This article will show how to integrate Microsoft Azure Application .Insights into a web application using ASP.NET Core 1.0 to Detect, triage, and diagnose issues in your web application

Visual Studio Application Insights   monitors your live application to help you detect and diagnose performance issues and exceptions, and discover how your app is used. It can be used with a wide variety of application types. It works for apps that are hosted on your own on-premises IIS servers or on Azure VMs, as well as Azure web apps.

Download source – 2 MB

STEP1 – Create Azure Account

You need to get a Windows Azure account. Everyone can open a Windows Azure account for free.

Check the link below for more information.

http://www.windowsazure.com/en-us/pricing/free-trial/ 

STEP 2 – Create a new Application Insight into your Azure Account

After authentication, select new resource, and choose the option Monitoring + Management

A new tab will be open.

Choose the option Application Insight

 

It will appear a new window, to configure this resource has you can check on the image below

On the field Name set your ApplicationInsight configuration Name. On my case it will be called Demo.
Select the application Type, on our demo it will be ASP.NET Web Application.

After select all options, select the button Create.

This resource will be created on the subscription selected and it will be displayed

STEP 3 – Create ASP.NET Core Web Application

 Using the Application Insights, it will be necessary create the project ASP.NET Core Web Application

Select the template Web Application on ASP.NET 5 Templates:

Add nuget package Microsoft.ApplicationInsights.AspNetCore to solution

STEP 4 – Configure Application Insights into your Web Application

 After install the package we should configure the key from the resource created on Azure Portal.

For that select the file appsettings.json on your solution.

Go to the Azure Portal into the Demo Application Insight created and check the settings like on image below:

Open the appsettings.json file and copy your instrumentation key from Azure portal

We also need to change our Startup class like this:

C#

using System; 
 
using System.Collections.Generic; 
 
using System.Linq; 
 
using System.Threading.Tasks; 
 
using Microsoft.AspNetCore.Builder; 
 
using Microsoft.AspNetCore.Hosting; 
 
using Microsoft.Extensions.Configuration; 
 
using Microsoft.Extensions.DependencyInjection; 
 
using Microsoft.Extensions.Logging; 
 
  
 
namespace AppInsightsDemo 
 
{ 
 
    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(); 
 
  
 
            if (env.IsDevelopment()) 
 
            { 
 
                // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately. 
 
                builder.AddApplicationInsightsSettings(developerMode: true); 
 
            } 
 
            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.AddApplicationInsightsTelemetry(Configuration); 
 
  
 
            services.AddMvc(); 
 
        } 
 
  
 
        // 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(); 
 
  
 
            app.UseApplicationInsightsRequestTelemetry(); 
 
  
 
            if (env.IsDevelopment()) 
 
            { 
 
                app.UseDeveloperExceptionPage(); 
 
                app.UseBrowserLink(); 
 
            } 
 
            else 
 
            { 
 
                app.UseExceptionHandler("/Home/Error"); 
 
            } 
 
  
 
            app.UseApplicationInsightsExceptionTelemetry(); 
 
  
 
            app.UseStaticFiles(); 
 
  
 
            app.UseMvc(routes => 
 
            { 
 
                routes.MapRoute( 
 
                    name: "default", 
 
                    template: "{controller=Home}/{action=Index}/{id?}"); 
 
            }); 
 
        } 
 
    } 
 

STEP 5 – Test Web Application

To test the integration of Application Insights into our application, just need to run it.

The collect of information, will start immediately.


Resources

Application Insights: https://www.visualstudio.com/products/application-insights-vs 

My personal blog: https://joaoeduardosousa.wordpress.com/