VS IndiaLinks – Which one is The Best ASP.NET Core 1.0 Hosting in India ? VS IndiaLinks – Which one is The Best ASP.NET Core 1.0 Hosting in India ? |Best and cheap ASP.NET Core 1.0 hosting.  If you are searching for the best web hosting service online, read all our  updated Web Hosting Reviews & Comparison 2017 to ensure you make a well informed decision. On this page we have investigated and reviewed all the major web hosting companies so you can easily differentiate features, pricing, support, service uptime and customer feedback. Every review was taken around the last 6 months and each hosting provider is reviewed on regular basis. If you have any experience with these website hosts services please feel free to write your own review of their service to help other people to find the best web hosting service for their online business. Our web hosting comparisons and reviews include customer support, features, pricing, value for money, security and reliability. All the best and we hope we help you to find your perfect hosting partner.

To choose the best Windows hosting for your websites, we will compare two of this India Windows hosting providers in the industry. This VS IndiaLinks comparison is about to make clear that who is a better option ASP.NET Core 1.0 Hpsting in India.

India Windows Hosting Review

Price ***** ***
Features ***** *****
Uptime ***** ****
Speed ***** ****
Technical Support  ***** ****

wI35 is the India’s #1 Windows hosting provider that offers the most reliable world class Windows hosting solutions for customers. provides high quality affordable India’s Windows hosting services for personal and companies of all sizes. You can host your website with an innovative, reliable, and a friendly India’s Windows hosting company who cares about your business.


Indialinks Founded in 1997 Based in Mumbai, India Industry Leader in Managed Hosting Solutions. They are providing now web hosting on Linux, Window, Window reseller hosting, Linux Reseller hosting, VPS Hosting. They also treat their costumer as family member and costumer’s trouble as their own trouble. VS IndiaLinks: Pricing & Features releases four plans called Personal, Developer, Business and Expert at the prices of INR 159.99/month 35% OFF INR 299.99/month 35% OFF INR 679.99/month 35% OFF andINR 1099.99/month 35% OFF . Three billing cycles with different prices are available in best India Windows hosting package. You can choose between 3-months, 1-year, 3-years and 5-years payment methods. also supports 30-days money back guarantee. On the contrary, IndiaLinks offers several kinds of India Windows hosting plan starting from $149.99/mo in regular time. IndiaLinks only provide the costumers yearly payment method.

In below, we create a feature-comparison table of this two best India Windows hosting companies:

Bandwidth30 GB16 GB
Disk Space3 GB8 GB
Windows Server Version 2008/2012Version 2008
IIS VersionIIS 7/7.5/8.0/10IIS 7
ASP.NET VersionASP.NET v. 5/4.6/4.5.2/4.5.1ASP.NET v. 2.0 /3.0/4.0
ASP.NET MVC VersionASP.NET MVC v. 5.1.1/5.15.2/
ASP.NET MVC v. 2.0/3.0
MSSQL VersionMSSQL 2008/2012/2014MSSQL 2008/2012


From the above comparison list, both of them are fully ASP.NET compatible. However, and IndiaLinks are different from each other in many features. They both support the .NET technology, like Windows Server, IIS, isolated application pool, LINQ, AJAX, Silverlight, Full Trust, URL rewrite module. But supports almost all version of Windows Server, ASP.NET, ASP.NET MVC, IIS and MSSQL database. also supports ASP.NET Core 1.0 hosting with affordable price. What’s more also provides unlimited domain while IndiaLinks still limit their domain. From the above table, we can conclude that has more rich-featured India Windows hosting that what IndiaLinks has offered. VS IndiaLinks: Uptime & Speed

To ensure uptime and speed, both and IndiaLinks have been investing much money and time. leverages best-in-class connectivity and technology to innovate industry-leading, fully automated solutions that empower enterprises with complete access, control, security, and scalability. They own and operate three world-class data centers strategically located in Mumbai (India), London (UK) and Washington D.C.(US). promise you in delivering 99.9% uptime. When it comes to IndiaLinks, they also located their data center in Chennai, Tamil Nadu and promise 99.9% uptime guarantee. However, most of IndiaLinks’s costumers are disappointed because of their slow speed website.

indialinkcmpr VS IndiaLinks: Technical Support offers 24/7 support through tickets, e-mail and contact form. When we contacted the their support representatives via e-mail, we got responses from within an average of 5 minutes. In the other hand, IndiaLinks only provide phone call for their costumer. We’ve tried to call their support but they always show the busy tune. We do believe that has more responsive support team.

Conclusion: VS IndiaLinks?

From the combination of high performance, responsive support, rich-featured hosting and reasonable pricing, we conclude that is better in serving India Windows hosting. It is clear that is a more favorable choice due to its cost-effective features and considerate customer service.

TOP LIST Best ASP.NET Core 1.0 Hosting with Special Discount in 2017

TOP LIST Best ASP.NET Core 1.0 Hosting with Special Discount in 2017 | Best and cheap ASP.NET Core 1.0 hosting. we had come out a list of the best ASP.NET hosting, which are rated independently based on the ASP.NET frameworks, Microsoft control libraries, databases, Microsoft technical support, and web hosting price.


To choose the best ASP.NET hosting for your ASP.NET websites, we recommend you going with the best ASP.NET hosting as following. You won’t go wrong with them that all of the best ASP.NET hosting services have been truly tested by our ASP.NET developers.

Rating5.0 of 55.0 of 54.0 of 54.0 of 5
Customer301 votes186 votes75 votes100 votes
Regular $4.49/mo

15% OFF


15% OFF


35% OFF


35% OFF

OS2016 R22014 R22012 R22012 R2
Control PanelPleskPleskPleskPlesk
Free DomainNoNoNoNo
Hosting SitesUnlimitedUnlimited
Bandwidth60 GBUnlimited50 GB50 GB
Disk Space5 GBUnlimited10 GB5 GB
Shared SSLYesYesYesYes
.NET Frameworks2.0/3.5SP1/4.5/5/core2.0/3.5SP1/4.0/4.5/5/core2.0/3.5SP1/4.5/5/core2.0/3.5SP1/4.5/5/core
ASP.NET MVC2/3/4/5/61/2/3/4/5/62/3/4/5/62/3/4/5/6
SQL Server2016201620162016
Remote IISYesYesNoYes
Trust LevelFullFullFullFull
Dedicated App PoolYesYesYesYes
Schedule JobsYesYesYesYes
Service LevelProfessionalProfessionalProfessionalProfessional
24×7 SupportYesYesYesYes
Full trustYesYesYesYes

The Best ASP.NET Core 1.0 Hosting in 2017

ASPHostPortal is a web hosting provider known for its professional ASP.NET hosting plans which are able to meet the demands of nearly all-sized businesses. Over the past 10 years since its reception, ASPHostportal has gained respect from both the developer and business communities.

The ASPHostportal ASP.NET hosting packages all comes with ASP.NET v2/v3.5/v4.6, ASP.NET core 1.0 and supports most versions of the frameworks including MVC, LINQ, AJAX and Silverlight. Also, they allow Full Trust to make sure that ASP.NET websites can run perfectly without the bother of the codes that cannot run. Right now, using this exclusive coupon link for checking out, the Basic hosting plan is $3.81/mo only, 15% off $4.49/mo you get originally.

The customers’ hosting experience is guaranteed by ASPHostportal excellent technical support team which is very helpful, knowledgeable and responsive to phone calls, emails and live chat. In addition, they offer every account with 30 days full money back and anytime post-rate money back guarantee. That makes customers’ ASP.NET hosting risk-free.

ASPHostPortal Statistik Review


To learn more about ASPHostPortal, visit

Why They’re the Best ASP.NET Core 1.0 Hosting

The following 5 checkpoints are main criterias on rating ASP.NET web hosting besides the consideration on the generic Windows web hosting features.

  1. Windows OS: the latest version of Windows OS is the key point of a quality ASP.NET hosting solution. And now, the best choices are Windows Server 2012R2, Windows Server 2012 and Windows Server 2008R2. In fact, all the recommended hosting companies support the mentioned Windows operating systems.
  2. ASP.NET Frameworks: as ASP.NET websites have to run in the corresponding .NET framework, it’s better that the web host can support most of frameworks from v1.1 to v4.0. In this case that you can have maximum flexibility for you websites and keep the possibility upgrading to the higher version.
  3. ASP.NET Trust Level: it’s configured for each website by .net infrastructure. you should know the exact configuration before the payment. in our research, 70% websites can be run only under the fully trust level. if your hosting company doesn’t tell that they support fully trust, you should be careful that your website may not run correctly in the host finally. surely, you can ask for money back but it’s time wasting.
  4. RAM: this is the maximum memory in the server that can be used for your site, which is configured in IIS application pool. Only sufficient RAM allocation can bring the website a reliable hosting condition.
  5. MSSQL Edition: MSSQL makes a big difference to store all data from the website, which is a Windows based database. Note that, the latest version of MSSQL is the SQL Server 2012.
  6. Control Panel: Plesk is the best reliable control panel for web hostingl and easy-to-use.
  7. Add-on Features: the installation required third party libraries are important when your website depends on then. E.G. Chat controls library, Altas library and more.
  8. knowledge of Microsoft technology support: you can easily call the technical support of the web host and ask some technical questions about ASP.NET website configuration and deployment. This is certainly important especially when you have a problem in the future.
Tips for Building an API in ASP.NET Core

Tips for Building an API in ASP.NET Core | Best and cheap ASP.NET Core 1.0 hosting. These days users expect a fluid, app-like experience on the internet. Thus, the new web is being built with APIs and single-page frontends. This means it’s more important that ever to build APIs that are easy to use, reliable, and scalable. ASP.NET Core makes it easy to build great APIs, but there are a few tips we’ve picked up that can help make your APIs even stronger and more scalable.

1. Set the Default Route for ASP.NET Core MVC

A lot of programmers who start using ASP.NET Core just use the default app.UseMvc(); line in the Configure method of Startup.cs. There are options that you can pass to the UseMvc function, like setting the default routes, which is one of the most overlooked:

This will set the root route of your API to: to call the DefaultController’s Get method.

What this does for you (aside from the obvious) is it sets the tone for a decent RESTful API. It also makes changes to URL strategy easier, including versioning the API in the URL easy to do if you set the URL strategy in one place.

2. Return IActionResult from .NET Core Controller Methods

Returning IActionResult from your controller methods affords the ability to take advantage of some of the helper methods and classes to ease returning proper HTTP results. The Ok method on the ControllerBase class will return an OkObjectResult that implements IActionResult and returns a 200 OK HTTP message to the caller. The NotFound method returns an object that sends a 404 NOT FOUND HTTP message.

There are quite a few others, but another extremely helpful one is the CreatedAtAction class that returns not only a 201 CREATED HTTP result but adds a header Location with the URL to access the newly created resource.

3. Use the .NET Async Pattern

Network calls by their very nature are asynchronous. It makes the most sense to create async controller methods that extend that asynchronicity when the controllers need to make database and external API calls.

The fact is, asynchronous support in .NET Core and the supporting libraries is very good these days. Using and creating asynchronous code is easy using async/await and libraries that support the Task pattern. The benefit is more simultaneous requests handled with the same hardware requirements.

Asynchronous code just performs better, and since it is so easy to create, why not do it?

4. Use .NET Attributes

Using attributes to decorate routes helps you to take advantage of some of the power of MVC. This may seem counterintuitive since I just told you to use the default routes. Decorating your methods and controller classes with just enough decoration for that class or method can help you take advantage of things like the CreatedAtAction.

You can also use attributes to help the JSON serializer do its job. You can use the NullValueHandling attribute to tell the serializer that when the value of a property is null, not to even serialize the property. You can change the property name that gets serialized so that you can stick with an internal coding standard and still return standard JSON names (like changing ‘MaxTitleLength’ to ‘maxLength’ when serialized). You can even set the order that properties are serialized so that more important properties are serialized first in the JSON documents.

5. Use Async Result Filters

Using Async Result Filters, you can shape the data in the last moments before it goes back to the caller. Usually, you’d add the properties you want (the way you want them) via an anonymous object. There are two problems with that approach, the first is that you need to do a lot of copying of properties and it violates the single responsibility principle. You could use AutoMapper to combat this property copying, but it doesn’t solve the second problem, which is adding new properties (like hypermedia).

Solution: An Async Result Filter will solve both problems and give you a cleaner, more maintainable code base.

BONUS: Try This Workaround to Improve Serialization of Self-Referencing Object Graphs

One of the problems with traditional .NET Web API serialization, is that it doesn’t handle self-referencing object graphs very well. The fact is, in good object-oriented objects there may actually be some reference loops, so it’s important to handle them gracefully.

In your ConfigureServices method of Startup.cs, change your MVC line from:

to :

In .NET 4.x a reference loop would cause an error. Once the serializer realized that serializing the object graph would cause a reference loop, it would fail and just send a 500 error. However, in .NET Core without the above JSON options added, the serializer serializes the object until it hits a reference loop and simply sends what has been serialized so far, ignoring the rest of the object, even if it could serialize the rest of the object graph easily.

What this line adds is, it tells the JSON serializer to ignore reference loops and continue serializing the rest of the graph. So far, this is just a workaround for the issue. It’s not perfect, but it’s better than just a failure.

The best way to handle this problem is to simply not have the problem. Normally, we would put these objects into DTOs that are not self-referencing and remove the problem altogether.

Billig Core ASP.NET 1.0 Hosting in Europa mit 15% Rabatt

Billig Core ASP.NET 1.0 Hosting in Europa mit 15% Rabatt | Beste und billig Core ASP.NET 1.0 Hosting in Europa. Sind Sie auf der Suche nach den besten Kern von ASP.NET 1.0 Hosting oder das Beste Windows Hosting? Ihre beste ASP.NET Core 1.0 Web Hosting Suche ist vorbei! Sparen Sie Zeit und Geld für die besten Windows Hosting Für finden Sie in unserer Top Core ASP.NET 1.0 Hosting Unternehmen mit großen Förderung empfohlene Liste!

Big Deal 15% RABATT billig Core ASP.NET 1.0 Hosting in Europa

hflbigsleHostForLIFE wurde als eine der besten ERKANNT Für Menschen, die mit den Leistungen unzufrieden sind, HostForLIFE bietet eine 30 Tage Geld-zurück-Garantie, so dass die Kunden ihre Konten innerhalb der ersten 30 Tagen zu stornieren und erhalten eine volle Rückerstattung. Wenn es um die Zahlung, zwei Zahlungsmethoden sind verfügbar, einschließlich CC und PayPal, um sicherzustellen, dass jeder Kunde die Dienste auf eine bequeme Weise erreicht.

Empfehlung: Wir empfehlen Ihnen dringend, Ihre Website oder Anwendung auf Web Hosting zu bewirten. Diese Webseite ist auch gehostet mit HostForLIFE und wir sind sicher, müssen Sie die Geschwindigkeit bemerkt haben. Sie können auch die Vorteile der speziellen Hostforlife’s Angebot und können günstige (Windows) Hosting mit unbegrenzte Bandbreite kaufen.

Günstigen Preis für eine Lösung mit hoher Verfügbarkeit
Auf Enterprise-Hardware
24/7/365 Kunden Betreuung und Unterstützung
99,9&Uptime Garantie
Spezielle App Pool
Amsterdam (NL) , London (United Kingdom), Paris (France), Frankfurt (DE) and Seattle (USA) Data Center

Warum diese Hosts bieten ASP.NET Hosting für unbegrenzte

Gut, das ist eine berechtigte Frage. Viele Leute fragen, warum Web Hosting Provider mit unbegrenzten ASP.NET Hosting. Alle Hosts, die billig und Unlimited Web Hosting, um Ihnen zu helfen, Ihre Anwendung auf IT-Test anbieten und wenn Sie zufrieden sind können Sie Ihr Paket auf eine höhere Ebene aktualisieren können. Einige andere will Studenten zu helfen, damit sie ihre Anwendungen entwickeln und testen.

Unlimitations und Einschränkungen der billigen ASP.NET

die meisten Hosting Pakete hosting Pläne kommen mit sehr wenig Speicherplatz und eine begrenzte Bandbreite. Wenn Sie planen, für sie ihr Geschäft Web site oder ein hoher Verkehr Website diese Pläne sind nicht geeignet, weil sie unbegrenzte Anzahl an Domains, Speicherplatz erhalten können auch die Bandbreite.


Top 10 Gründe, mit unseren Top ASP.NET Core 1.0 Hosting Provider Empfehlung auf Host:

  • .NET Hosting Services von
  • Microsoft-recognized .net Hosting Unternehmen
  • preisgekrönte .NET HOSTING Lösungen
  • Neueste getestet. NET Hosting Technologien
  • Beste .NET Hosting Preise
  • starken Kunden Testimonials
  • 24×7 Telefon- & E-Mail-Support
  • 99,9% Uptime Garantie
  • Geld-zurück-Garantie

ASP.NET Hosting Anforderungen

Windows Hosting Unternehmen die aktuellste unterstützen sollte. NET-Technologien und die aktuellsten Versionen. Stellen Sie sicher, dass, wenn Sie ASP.NET 4.6 hosting Core/benötigen, IIS 8, MVC 6, MS SQL 2016 Ihr Gastgeber unterstützen Sie. Auch wenn Sie nicht die neuesten Versionen fragen Sie sich, wenn Sie sie in der nahen Zukunft verwenden werden? Auch die Art und Weise Sie ihrer Datenbank Server aufbauen konnte und Website Bereitstellung prüfen. Die meisten der besten ASP.NET Hosts unterstützen die neuesten und innovativen .NET hosting Technologien.

Nutzen Sie die leistungsstarken, on-demand .NET Hosting die Leistung Ihrer IT-Infrastruktur zu steigern. Mehrere Web hosting Pläne zur Verfügung stehen, so dass Sie die nötige Flexibilität, um die Services je nach Ihren Bedürfnissen anpassen. Verlassen Sie sich auf Windows Web Hosting schnell zu skalieren und die Bereitstellung von IT-Ressourcen, wenn Sie sie benötigen, und zahlen für die Ressourcen, die Sie nutzen. Die .NET Web Hosting erhalten Kunden eine zuverlässige Leistung und Kundendienst zu einem erschwinglichen Preis.

WinHost VS HostForLIFE – Which Is the Better ASP.NET Core 1.0 Hosting

WinHost VS HostForLIFE – Which Is the Better ASP.NET Core 1.0 Hosting | Best and cheap ASP.NET Core 1.0 hosting. WinHost and HostForLIFE are two reputed web hosting providers with more than ten years’ experience in the market. WinHost pays special attention to Windows hosting while HostForLIFE offers a set of hosting solutions, including reseller hosting, VPS hosting, shared hosting, dedicated hosting, as well as the Windows hosting.

Because of their great reputation, it is not easy for webmasters to figure out who is the better provider for ASP.NET Core 1.0 hosting. This WinHost vs HostForLIFE comparison is about to fix this issue. We will focus on their plans, performance, customer service and performance.

In the beginning, you can read the overall ratings about them.
Loading SpeedstarsGMyxz
Technical SupportstarsGMyxz

Price and Money Back Guarantee

With regard to the Windows hosting packages, WinHost releases three plans called Basic, Max and Ultimate at the prices of $3.95/mo, $7.95/mo and $15.95/mo.These prices are only valid for orders made through the following promotional link, 20% off the regular prices. Three billing cycles with different prices are available. For instance, the prices of the primary plan are rated at $3.95/mo for 2-year term, $4.95/mo for 1-year term and $5.95/mo for 3-month term. At the same time, you don’t need to pay additional fee for setup and Whois domain privacy., in comparison, launches two plans, including Personal and Enterprise. They are charged start  €3.49/Mo. 15% OFF€5.50/Mo. 15% OFF, €8.00/Mo. 15% OFF and €10.99/Mo. 15% OFF in regular time. Now you are fortunate enough to get the lowest prices of €2.97/Mo, €4.67/Mo, €6.80/Mo and €9.34/Mo 15% OFF discount. The company offers five billing cycles, including 3 month, 6 months, 1 year, 3 years and 5 years.

By the way, both companies offer a 30-day money back guarantee to mitigate purchase worries and risks. To sum up, HostForLIFE gains the upper hand in terms of plans and price since it offers more options and lower prices.


All the basic Windows hosting features are guaranteed by them, including sufficient disk space and monthly data transfer, multiple sub-domains and add-on domain, enough FTP accounts and email storages, as well as advanced Windows hosting technologies, such as 2012/2008 Windows servers, IIS 8/7, Isolated Application Pool, ASP.NET 2.0 to 4.5, MVC 1/2/3/4/5, AJAX and many more.

In the following, we choose the Basic plan from WinHost and Personal plan from HostForLIFE to make a clear comparison table about their features.

Plan in ReviewBasicClassic
Disk Space3 GBUnlimited
Bandwidth50 GBUnlimited
PHP 7NoYes
Hosted Website11
IIS Remote ManagementYesYes
ASP.NET3.5/4.0/4.53.5/4.0/4.5/5/core 1.0
MySQL 5yesyes
1-Click Free InstallationYesYes
Control PanelWebSitePanelPleskPanel

The table above indicates that WinHost and HostForLIFE have their own merits. For example, the former company offers the latest versions of IIS, ASP.NET and MS SQL while the later one includes more disk space and monthly data transfer.

As for the control panel, HostForLIFE uses PleskPanel while the other web host utilizes Website as their control panel. Besides, 1-click free installer allows the customers of the two companies to easily install many applications, such as DotNetNuke, nopCommerce and WordPress.


HostForLIFE locates their world-class data centers in the US and Europe. All the data centers are supported by high performance servers and network infrastructure, handprint system and redundant connection to ensure fast speed. In addition to that, the network of this company is monitored by their well-knowledgeable and experienced engineers who can solve potential event and accident.

More than 99.9% uptime is realized by HostForLIFE.


Also,Winhost works well to offer over 99.9% uptime. This web host uses the state-of-art server hardware, network, electrical system, HVAC, redundant power and fire suppression system to provide customers with a great Window hosting experience.


Technical Support

Backed by hundreds of well-educated and experienced technicians, both WinHost and HostForLIFE are confident to provide around-the-clock technical support. No matter when you need help, you are accessible to contact their support personnel. However, a disadvantage of HostForLIFE is that this company does not offer live chat and phone call support, which might cause some inconvenience for webmasters.

The two companies have some other resources in their support center and knowledgebase. Especially, The responses for their users confirm that the technical support of the two web hosts is satisfactory.


From this comprehensive comparison, we can conclude that both WinHost and HostForLIFE are great choices for ASP.NET Core 1.0 hosting. HostForLIFE  is more suitable for the webmasters who pursue faster speed while winhost is designed for those who want better technical support.

Structured Logging in ASP.NET Core

Structured Logging in ASP.NET Core | Best and cheap ASP.NET Core 1.0 hosting. ASP.NET Core is a complete rewrite of ASP.NET, targeting .NET Core on Linux and OS X as well as Windows.

Among the many upgrades in the new version is a completely rewritten diagnostic logging pipeline that not only emits interesting events from the framework, but uses structured logging to do so.

Structured Logging in ASP.NET Core

Like Serilog, ASP.NET Core uses message templates (named placeholders in format strings) to capture structured properties along with textual log data:

If this event is written out to the console, it will be formatted as plain text:

This is ideal during development, when a readable text format is preferred.

But, when the logging provider supports structured data, the properties associated with the event can be preserved in a machine-readable form:

Armed with structured log data, it’s easy to slice and dice logs with queries like:

This is a game-changing capability for complex distributed apps, or when log data runs more than a few hundred events in a day.

Setting Up

These instructions assume that you’ve created a new ASP.NET web application using the template in Visual Studio (File > New… > Project > ASP.NET Web Application).

Out of the box it should look something like this:


The packages we’ll install are:

  • Serilog – a logging framework for structured data
  • Serilog.Extensions.Logging – an ASP.NET logging provider that implements ASP.NET’s ILogger on top of Serilog
  • Serilog.Sinks.Seq – a Serilog sink that ships events to Seq over HTTP

To really take advantage of ASP.NET Core’s logging today, you’ll need a complete logging provider like Serilog to handle the task of shipping log events to most back-end storage targets, as only a few basic providers such as a console logger are there today. Over time it’s likely ASP.NET Core will gain more capabilities of its own in this area.

Crucially, all of the packages supporting ASP.NET Core are currently pre-release, so make sure to include the -Pre switch when installing from the Package Manager Console:

Then, the following lines added to Startup.cs will configure the Serilog back-end:

This assumes you have Seq running locally on your development machine, listening on the default port. Replace http://localhost:5341 with the address of you Seq server if it lives somewhere else.

(Adding Enrich.FromLogContext() here ensures that any events written directly through Serilog will seamlessly pick up correlation ids like RequestId from ASP.NET.)

Finally, also in Startup.cs, add Serilog to the ILoggerFactory that’s passed into the Configure() method:

When you refresh the application, all kinds of interesting data from the framework’s inner workings will appear in Seq:


In this screenshot you can see a few familiar MVC processes going on – requests started and finished, actions invoked and views selected.

Writing custom events

It would be interesting, but fairly underwhelming, if the story ended here. The real value in the new logging pipeline is that your own application events get the same treatment.

The simplest way to start logging from your own controllers is to take a dependency on type ILogger<T>:

The T generic parameter is passed so that log events can be tagged with the class that raised them.

ILogger<T> has methods like LogInformation(), LogWarning() and LogError() to write events to the logging pipeline:

Look carefully at the properties attached to the resulting event:


The first thing to notice is that the MachineName argument we supplied in the format string is there as a first-class property that can be used when searching for events.

The second thing to observe is RequestId – this little gem is added automatically by the ASP.NET framework to all events raised during a web request. Filtering down to a single RequestId will find all events related to just that HTTP request – your own, and the ones raised by the framework. If you don’t use this technique already, it’s something you absolutely must try.

Alternatives for ASP.NET 4.6

Not using ASP.NET Core just yet? Check out the Serilog support for ASP.NET 4.6, which adds a lot of structured logging goodness through a NuGet package.

Happy logging!

How To Setting Up VS 2015 for ASP.NET Core RTM 1.0 and Angular 2 Final/RTM ?

How To Setting Up VS 2015 for ASP.NET Core RTM 1.0 and Angular 2 Final/RTM ? | Best and cheap ASP.NET Core RTM 1.0 hosting. In this post I will explain how to setup Visual Studio 2015 in order to develop an Angular 2 RC3 application hosted inside ASP.NET Core project.  I of course read the quick start first.  You need to make sure to install VS 2015, you can use Community edition of you want.  You would also need to install ASP.NET Core.

Let’s get started.  Create new ASP.NET Core project.

Select empty template to keep everything simple for getting started demo.


Let’s add static files support to serve a plain vanilla HTML page.  Open project.json file and add the static files line from below.

I also added support for DotNet.Watcher tools which make it easier to make changes to C# code and have the process automatically compile and restart as needed.

Now we can add a page which will host our Angular app.  Again, add just a plain HTML page under wwwroot folder, since that is the root of our deployable Core application.  You can just right click on that folder, add new item, then pick HTML page template.  I am calling mine index.html.  In order to see this page we need to turn off preloaded startup code and replace it with static files server.  Open up Startup.cs file and replace Configure method with the following.

Now we can test the host page.  Open up VS command prompt and navigate to the project folder (NOT solution folder).  Type “dotnet  watch run”.  Your app will compile and Kestrel web server with start.  Open browser and navigate to http://localhost:5000/index.html.  You will see the host page.  To make sure edit the index.html page and add some content to it.  It is time to start up Angular 2 portion.  I like adding NPM support to the project from command line.  From the same command prompt type “npm init” to initialize NPM file.  Follow the prompts, giving some meaningful answers.  Once this is done, switch to visual studio.  You will see that dependencies node in project explorer with have npm listed.  Right click on that node and select open package.json. We need to add all Angular 2 scripts and dependencies by adding dependencies and devDependencies nodes as shown below.

All packages that start with @angular are angular core packages.  This is different from beta versions, which only had a single package.  Other packages are supporting packages for angular 2.  In order to proving TypeScript support, we will use typings NPM module, which is under devDependencies.  Give VS a minute to restore the packages after saving package.json file.  If you get an error, just type “npm install” at the command prompt.

Now we need to install code JavaScript typings files for TypeScript.  At the same prompt type “typings install  –global –save dt~core-js”.  Once completed, you will see typings folder in project explorer, with core-js folder under it.

In the next step we will setup compilation options for TypeScript.  Add new item to the root of your project, selecting TypeScript Configuration File item template.  Change the content to look as follows.

We are adding decorator options, which are required for Angular 2.  We are setting module to use systemjs, which is the default for all the demos I have seen.

Now I am going to setup gulp to make my development flow a bit smoother.  If you do not have gulp installed globally, type “npm install gulp”  at the command prompt.  After that you can add new item to the root of the project, selecting Gulp Configuration File item template.  Open gulpfile.js and replace the content with the following.

What is going on here?  Third party task copies necessary Angular 2 scripts from node_modules folder to the same folder under wwwroot.  Copy task copies our own application files, which will be placed under app folder under project root to wwwroot folder as well.  Finally, watch task will monitor the changes to app folder and re-copy the files wwwroot folder by firing copy task.  By default we will run all three tasks when we run gulp every time.

Time to write application code.  Create new folder called “app” under project root.    Now we need to create root component.  We will add app.ts file with the following code.

We created a new class called App.  It is decorated with a component attribute.  We specify the selector or tag that will be replaced with our component.  We also specify the HTML that will be injected and bound to the component.  The component just has a property and a method to test data binding.

Now we need to create a starting module.  Let’s call the file appModule.ts

This class actually does not have any executable code, just a decorator that defines our root module.  It imports compile module, BrowserModule, necessary for compiling and bootstrapping Angular code in browser.  it contains our single App component that we both declare and bootsrtap, setting it as entry point into the application.

Finally, add new item to shell folder, picking TypeScript file template.  Change the name to main.  This will be our bootstrapping code for Angular 2 application.

Now we need to configure systemjs module loader.  Create new JavaScript file called system.config.js under wwwroot folder.  This is the only file we will add there.  We could also add it under app folder if we wanted to.  Here it its content.

We are specifying our app folder as a package for system js.  We are also adding core angular packages, including rxjs, reactive extensions.  We are configuring systemjs by calling config method and passing our packages map.  Finally we are starting app package.  Previously in the same file we specified that the entry point for it is main.js.

It is time to edit our index.chtml page and add the necessary scripts.  We will start by creating views folder with some stock files.  I am adding _ViewStart.cshtml under Views.

This code just sets up default layout page for all our views.  Now we just need default view.  I am going to create home folder and single view under it Index.cshtml.  Its content is very simple.

It just contains the tag for our root component.  Now the import part of adding out layout page, _Layout.cshtml under Views/Shared folder.  It just contains all the necessary libraries.

It also setups up configuration object, which we do not technically need in this sample app, but it is a good illustration on how to inject server side configuration into client side JavaScript.  We are keeping node_modules and third party libraries folder, but to be sure, we are not using entire folder, we just compy necessary stuff via gulp (see above).

Time to create C# controller under Controllers folder.  We will call it HomeController.

You can now build the project in the Visual Studio just in case.  Then switch to command prompt, navigate to the folder where our project is (NOT solution).  Just make sure you see project.json file.  Now we need to run gulp to copy files around.  Type “gulp” and let the process finish.  Now open second prompt, nvaigate to the same folder and type “dotnet watch run”.  This will compile if necessary, start runtime process and watch for any changes.  Let this finish as well.  Make sure you see something like the following:

Final step.   Open browser and navigate to the URL above.  You should see the following.


Feel free to click on a button to make sure the method in your App component got bound properly as well.  Also feel free to make changes to the App component and refresh the page to see them.

In this post we achieved a lot.  We setup new .Net Core project, created default controller and cshtml page, setup Angular 2 minimal application, setup watcher for .NET and TypeScript code to make changes without manual compilation and ran our project.  Quite a bit of work.

How To Create Help Desk Web Application using ASP.NET Core 1.0 ?

How To Create Help Desk Web Application using ASP.NET Core 1.0 ? | Best and cheap ASP.NET Core 1.0 hosting. Suppose you work for a small to midsize company that employs 50-100 workers. The Help Desk — a subsidiary of the Information Services Division — is in charge of trouble tickets regarding general PC issues such as email, viruses, network issues, etc. Initially, the Help Desk team stored this information in Excel spreadsheets, but as the company has grown, managing these spreadsheets has become tedious and time consuming.


The Help Desk has asked you to devise a more efficient solution that could be developed internally, saving the company money. As you start to think about it, the following requirements are apparent: fields for the submitter’s first and last name, as well as their email address. You’ll also need combo boxes for indicating ticket severity (low, medium, high), department, status (new, open, resolved), employee working on the issue, as well as an area for comments. Of all the solutions available, creating an internal help desk Web application with ASP.NET is relatively simple.

In the following article, we’ll see how to implement these features in an ASP.NET help desk Web application using a database-driven approach,

Creating the JavaScript File

Because creating the JavaScript file is the easiest of the work left, we’ll do this next. From the Solution Explorer, follow these steps:

Creating the Help Desk Class

Now that we have our data coming in, we need to be able to record a help desk ticket submission. We need to create an event handler in a class to handle it. Let’s first create a help desk class by doing the following:

  •     Right click the project solution.
  •     Choose Add>New Item.
  •     In the Add New Item window, select Class.cs.
  •     In the name text field, type “HelpDesk” and then click Add.

Double click HelpDesk.cs from the Solution Explorer, which will show the empty class as shown below:

We need to import three libraries as shown below:

The first library (System.Data) allows us to work with stored procedures in ADO.NET, the second (System.Configuration) allows us to reference a connection key from configuration file and the last (System.Data.SqlClient) one allows us to connect to SQL Server.

How to Migration from ASP.NET Core 1.0.x to 1.1

How to Migration from ASP.NET Core 1.0.x to 1.1 | Best and cheap ASP.NET Core 1.0 hosting. In this review I will explain about How to Migration from ASP.NET Core 1.0.x to 1.1.

This post is coming out of order so the repo that goes with this post will contain some items not covered in posts yet. The starting point of the repo can be found here.


Make sure you already have Visual Studio 2015 Update 3 installed with .NET Core 1.0.1 tools Preview 2 installed. If not use the previous links to install the needed versions. Next head over to the download page for .NET Core and under All downloads and select Current and SDK and select the download for your OS.



Project.json is the file that contains all the versions of assembles used by the application. A couple of items need to edited by hand and the rest can be updated using NuGet UI or you can change them all by hand if you like.

First the by hand items. The platform version needs to be updated to 1.1.

The second by hand item is the net core app version in the frameworks section.

Here is the resulting dependencies and tools sections.

Make note that using the NuGet UI will update the dependencies but not the tools section. For some reason the tools section doesn’t seem to have intellisense so I ended up searching the NuGet site to find the new versions. If you do end up changing the tooling version I recommend doing a  dotnet restore in the project directory from the command prompt to ensure the proper versions get downloaded.

Wrapping up

As I said this was a really pain less migration. Make sure you check out the release pages ( .NET Core 1.1, ASP.NET Core 1.1 and Entity Framework 1.1) for the details on what has changed. For example ASP.NET Core has gotten significant performance increases with this release as well as URL Rewriting Middleware and Response Caching Middleware.

It has been less than six months since the initial release of ASP.NET Core until the 1.1 release which a huge increase in the pace of releases compared regular ASP.NET. From what I have see this is a pace the team will continue.

ASP.NET Hosting Tutorial – Dependency Injection with ASP.NET Core 1.0

ASP.NET Hosting Tutorial – Dependency Injection with ASP.NET Core 1.0 | Best and cheap ASP.NET Core 1.0 hostingDependency is an object that can be used and an injection is the passing of that dependency to a dependent object that would use it. ‘Dependency Injection’ is a design pattern and, as the name suggests, it is taking a dependency and injecting into a client or caller and it implements inversion of control. Using this pattern, a developer injects dependencies into objects instead of objects creating their own dependencies. This way, more flexibility and decoupling can be achieved.

Best ASP.NET Hosting in Australia Click Here !

Most of the applications using MVVM or MVC or other design patterns use DI and use constructor injection in many cases by passing the view model to view at the constructor level. That way, you can maintain the view’s code free of any view model logic being coded in it. One more example is that you can decouple the data source connection dependency from the repository class that fetches data from database by passing a connection string as dependency, thus allowing data source to work with any repository by taking the connection string that is sent by caller. Here, the control is inverted by handing the responsibility of creating the connection from the repository class to the caller.


Most of the ASP.NET developers would have implemented DI using one or more of the following approaches:

  • Constructor injection: Injects the dependency at the constructor level.
  • Parameter injection: Injects the dependency at the parameter level.
  • Setter injection: Injects the dependency at the property level.
  • Interface injection: Injects the dependency at the interface level.

There is some confusion among developers about when to use which injection, and it depends on situation. If the injected object is used by more than one method in the class, the constructor level injection is the most appropriate because dependency is resolved one time at the constructor level but, if the dependency is used only by one method, parameter injection is preferred. But, in some situations, the class depends on another class but also can work without it. For example, in logging purposes, a class can work without logging, but it can write logs if you define dependencies as public properties. Dependency Injection is for objects that have complex dependencies. Controllers, services, adapters, and repositories are the kind of objects that can be added to DI. Static access to services and HttpContext are not good practice.

Sample constructor injection code can be as shown below, where the employee repository is injected at the constructor level and is resolved one time. However, it can be used many times in the class methods.

There are many dependency injection frameworks that automate resolving dependencies. This article focuses on dependency injection implementation details using ASP.NET Core 1.0. If you design an application to use DI, it’s helpful to have a class dedicated to creating these classes with their associated dependencies. These are known as Inversion of Control (IoC) containers or Dependency Injection (DI) containers. A container is responsible for providing instances of types that are requested from it.

ASP.NET Core 1.0 has a built-in container that supports constructor injection by default.

ASP.NET’s container refers to the types that are managed by ASP.NET Core’s IoC container. A built-in container’s services can be configured in the ConfigureServices method in the application’s Startup class. You can use it everywhere DI with ASP.NET Core 1.0. The first step is to use Framework-Provided Services. ASP.NET Core 1.0 introduces a new method, called ConfigureServices, in the Startup class. Once you know the list of service you have to use in the application, you can define the IServiceCollection and then add those services the collection and input that to the ConfigureServices method.

We can define sample service as follows:

The next step is to add the service to the DI container. An ASP.NET service can be configured with three main registration options, as shown in the next sections.


If you need to create a service each time it is requested, Transient lifetime is the best option. This mostly suits stateless services. Mapping is done between the interface and concrete type and, due to this new instance, is created every time it is requested. To register EmpService to Service Collection, you can use the following syntax.


If you need to create new instance once per request, the Scoped life time can be used.


If the application requires singleton behavior, Singleton lifetime services can be used because the new instance is created the first time it is requested and then every subsequent request will use the same instance.

An instance also can be directly added to the services container. In such scenarios, this instance will be used for all subsequent requests for Singleton-scoped instances. Singleton service is lazy-loaded the first time it is requested, whereas the Instance service is created in ConfigureServices.

You can crate extension method to the IServiceCollection and register multiple services used in the application in MVC. All services needed by MVC middleware are added by the following extension.

We can define extensions as shown in this next code snippet:

Pass this services list to the ConfigureServices method to register them, as shown below.

If you want to replace the built-in container with their preferred container, the ConfigureServices signature can be changed to return IServiceProvider; a different container can be configured and returned. There are many IOC containers available for .NET; some of them are listed below:

  • Spring Framework: This framework offers Dependency Injection and a number of other capabilities.
  • PicoContainer: Tightly focused DI container framework.
  • HiveMind: Another DI container framework.
  • XWork: This is a command pattern framework that very effectively leverages Dependency Injection.
  • Autofac: Autofac is an addictive DI container for .NET 4.5, Silverlight 5, Windows tore apps, and Windows Phone 8 apps.

To add the third-party container, we have to add the appropriate container package(s) to the dependencies property in project.json as demonstrated below:

We then have to configure the container in ConfigureServices and return an IServiceProvider:


I hope this post gives you knowledge on the DI, a built-in container for DI in ASP.NET Core 1.0, how it works, and about using third-party containers with it.