European ASP.NET 4.5 Hosting BLOG

BLOG about ASP.NET 4, ASP.NET 4.5 Hosting and Its Technology - Dedicated to European Windows Hosting Customer

ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: How To Use An Area In ASP.NET Core?

clock October 16, 2018 11:40 by author Peter

In order to include an Area in an ASP.NET Core app, first we need to include a conventional route in the Startup.cs file (It's best to place it before any non-area route).

In Startup.cs, configure the method.
    app.UseMvc(routes =>  
    {  
        routes.MapRoute("areaRoute", "{area:exists}/{controller=Admin}/{action=Index}/{id?}");  
        routes.MapRoute(name: "default", template: "{controller=Home}/{action=Index}/{id?}");  
    });   


Then, make a folder named Areas in the app root and make another directory named Admin inside the former. Inside the admin folder, create the following folders (ViewComponent is optional).

Now, we will create a Controller inside the Controllers folder named AdminController.
Now, in order for that to work, you'll need to create Views for all actions that return one. The hierarchy for Views is just like what you have in a non-area Views folder.

Now, you should be good to go!

Question - What if I want to have another Controller inside my Area?

Answer -
Just add another Controller beside AdminController and make sure the routes are like the following,
    [Area("Admin")]  
    [Route("admin/[controller]")]  
    public class ProductsController: Controller {  
        publicProductsController() {  
                //  
            }  
            [Route("{page:int?}")]  
        publicIActionResult Index() {  
            returnView();  
        }  
    }   


The important part is [Route("admin/[controller]")]. With that, you can keep the style of routing to admin /controller/ action/.

HostForLIFE.eu ASP.NET Core 2.2.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.

 



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: End-To-End Testing Of Your Web Applications With Canopy

clock October 9, 2018 09:07 by author Peter

Why Is Canopy Stabilization Layer Built on Top of Selenium?
One of the most crucial concepts of Canopy is reliability - when performing an action the framework tries, during the time span specified via elementTimeout or compareTimeout or pageTimeout, before failing. This improves the experience of writing tests.
Expressiveness

The syntax looks pretty self-explanatory:
    "Bio should contain twitter link" &&& fun _ ->      
        url "https://github.com/
peter"      
        ".user-profile-bio" == "https://twitter.com/
peter

F#
In one of my previous articles, I have already expressed my opinion regarding power and expressiveness of F#.
Writing More Tests

To start, just create a console application, install nuget package canopy and create tests in Program.fs like below:
    open canopy.configuration 
    open canopy.runner.classic 
    open System 
    open canopy.classic 
     
    //set path for chrome direver explicitly 
   chromeDir <- "C:\\" 
    start chrome 
     
    "Left bottom repostitory should be stationwalk.server" &&& fun _ -> 
        //visit the following url 
        url "https://github.com/
peter
        //get 4th child of the following selector 
        let repo = nth 4 ".pinned-repo-item" 
        //get element with the following selector inside repo element 
        let firstRepoCaption = repo |> someElementWithin ".js-repo" 
        match firstRepoCaption with     
        | Some caption -> read caption == "stationwalk.server" //if found read element caption  
                                                               //and compare it 
        | None _ -> failwith "Element not found" //if none element found throw an exception 
     
    "Left bottom repostitory should be stationwalk.client" &&& fun _ -> 
        url "https://github.com/
peter
        let repo = nth 5 ".pinned-repo-item" 
        let firstRepoCaption = repo |> someElementWithin ".js-repo" 
        match firstRepoCaption with 
        | Some caption -> read caption == "stationwalk.client" 
        | None _ -> failwith "Element not found" 
     
    "Bio should contain twitter link" &&& fun _ -> 
        url "https://github.com/
peter" 
        ".user-profile-bio" == "https://twitter.com/peter" 
     
    run() 
     
    printfn "Press any key to exit..." 
    Console.ReadKey() |> ignore 
     
    quit() 


Accessing IWebDriver
If you've ever written tests with Selenium using C#, you might be aware of IWebDriver interface which you still might use for some advanced configuration. For example, let's say we want to run our tests with a browser opened fullscreen. Then we can add the following function to our Program.fs file
    let maximizeBrowser (browser : IWebDriver) =     
      browser.Manage().Window.Maximize() 


Accessing IWebElement
Most of canopy's assertions, i.e., == accept as a parameter either a string which can be css or xpath selector or instance of IWebElement type which again might be already familiar to you if you've ever written selenium tests using C#. So let's say we want to upload something into file upload control.
    let uploadFile fullFilePath = 
      (element "input[type='file']").SendKeys(fullFilePath) 


Splitting Up Big File
Patterns which I've practiced to keep test project maintainable include extracting selectors into page modules and moving tests to separate files.

Let's revisit our github example by moving out selectors into the separate module:
    module GithubProfilePage 
     
    let pinnedRepository = ".pinned-repo-item" 
    let bio = ".user-profile-bio" 


Now we can reference them in the test which we'll move into a separate module too:
    module GithubProfileTests 
     
    open canopy.runner.classic 
    open canopy.classic 
     
    let all() = 
        context "Github page tests" 
     
        "Left bottom repostitory should be staionwalk.server" &&& fun _ -> 
            url "https://github.com/peter" 
            let repo = nth 4 GithubProfilePage.pinnedRepository 
            let firstRepoCaption = repo |> someElementWithin ".js-repo" 
            match firstRepoCaption with 
            | Some caption -> read caption == "stationwalk.server" 
            | None _ -> failwith "Element not found" 
     
        "Right bottom repostitory should be staionwalk.client" &&& fun _ -> 
            url "https://github.com/
peter
            let repo = nth 5 GithubProfilePage.pinnedRepository 
            let firstRepoCaption = repo |> someElementWithin ".js-repo" 
            match firstRepoCaption with 
            | Some caption -> read caption == "stationwalk.client" 
            | None _ -> failwith "Element not found" 
     
        "Bio should contain twitter link" &&& fun _ -> 
            url "https://github.com/peter" 
            GithubProfilePage.bio == "https://twitter.com/peter" 


Our Program.fs will look like this:
    open canopy.configuration 
    open canopy.runner.classic 
    open System 
    open canopy.classic 
     
    chromeDir <- "C:\\" 
    start chrome 
     
    GithubProfileTests.all() 
     
    run() 
     
    printfn "Press any key to exit..." 
    Console.ReadKey() |> ignore 
     
    quit() 


Running Test in Parallel
Recently, Canopy had a major upgrade from 1.x to 2.x and one of the great new features is the ability to run tests in parallel.

Let's revisit our example by using this ability:
    module GithubProfileTests 
     
    open canopy.parallell.functions 
    open canopy.types 
    open prunner 
     
    let all() =   
        "Left bottom repostitory should be stationwalk.server" &&& fun _ -> 
            let browser = start Chrome         
            url "https://github.com/
peter" browser 
            let repo = nth 4 GithubProfilePage.pinnedRepository browser 
            let firstRepoCaption = someElementWithin ".js-repo" repo browser 
            match firstRepoCaption with 
            | Some caption -> equals (read caption browser) "stationwalk.server" browser 
            | None _ -> failwith "Element not found" 
     
        "Right bottom repostitory should be stationwalk.client" &&& fun _ -> 
            let browser = start Chrome         
            url "https://github.com/
peter" browser 
            let repo = nth 5 GithubProfilePage.pinnedRepository browser 
            let firstRepoCaption = someElementWithin ".js-repo" repo browser 
            match firstRepoCaption with 
            | Some caption -> equals (read caption browser) "stationwalk.client" browser 
            | None _ -> failwith "Element not found" 
     
        "Bio should contain twitter link" &&& fun _ -> 
            let browser = start Chrome         
            url "https://github.com/
peter" browser 
            equals GithubProfilePage.bio "https://twitter.com/
peter" browser 

The key trick to follow here is that each test operates now with its own copy of browser and assertions are now taken from open canopy.parallel.functions to accept browser as an argument.

Headless Testing
Testing in a headless browser seems to be the new black now. Although I don't share the sentiment, I still can assure you that testing in headless browsers is supported by Canopy. You can run your tests in headless Chrome as follows:
let browser = start ChromeHeadless 

I hope this article has convinced you that Canopy is a robust and easy to use framework which can be used in building end-to-end testing layers of your application.

HostForLIFE.eu ASP.NET Core 2.2.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.

 



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: System.Diagnostics Useful Actions

clock October 2, 2018 09:51 by author Peter

The namespace System.Diagnostics provides a set of attributes and classes to interact with the system process, event managers, performance counts etc. This namespace can help us too in debugging jobs.

Let’s review the useful actions inside System.Diagnostics namespace.

DebuggerDisplay Attribute
DebuggerDisplay attribute drives the string format with debug screen, which shows the value of: class, properties or fields.

For this same task, it is best known override ToString method, but use DebbugerDisplay attribute is a better choice, because this does not modify the data structure as it only interacts with Visual Studio debbuger screen. Override ToString method for only this purpose can give problems because many actions in .NET takes this value for default, for example bindings in WPF.

This attribute supports delegates, properties, fields and assamblies.

Example
[System.Diagnostics.DebuggerDisplay("{ID} - {Model}- {Manufacturer} - {ProductionDate}")] 
public class Car 

    public int      ID             { get; set; } 
    public string   Model        { get; set; } 
    public string   Manufacturer   { get; set; } 
    public DateTime ProductionDate { get; set; } 
}  



DebuggerHidden Attribute
DebuggerHidden attribute prevents the compiler from stopping in constructors, methods, properties and indexers declarations.
In mentioning this later, my comment might sound lightweight, but in the practice, this can save time push key F11 in debugging.

Example
[System.Diagnostics.DebuggerHidden] 
public static List<Car> GetData() 

    var result = new List<Car>() 
    { 
        new Car{ ID = 1, Manufacturer = "Ford",   Model = "Mustang", ProductionDate = DateTime.Today }, 
        new Car{ ID = 2, Manufacturer = "Nissan", Model = "Micra"  , ProductionDate = DateTime.Today } 
    }; 
 
    return result; 
}  


Debugger.Launch

Occasionally, we can’t debug the code of a library, Service etc. because it is not accessible or we can’t add project to our solution. In this case, we can use the Debugger.Launch() method and Visual Studio opens a debug Window and we can debug its code.

When executed, the line Systen.Diagnostics.Debbuger.Launch() opens a MessageBox with the instance of Visual Studio Debugger Options.

In this window, we can choose, if we open a new stance of Visual Studio (all versions) or if we re-use an existing instance. We can debug the code, as shown below.

Conditional Attribute
Conditional attribute allows us to indicate a condition to the methods so that the compiler executes or does not execute its content. We can use it with the precompiler sentences as DEBUG.
static void Main(string[] args) 

 
    DebugMethod(); 
 
 
    Console.Read(); 

 
[System.Diagnostics.Conditional("DEBUG")] 
public static void DebugMethod() 

    Console.WriteLine("Execute Debug Method"); 
}  


It will only run if the solutions configurations are debugged.

The condition doesn’t exist for RELEASE, therefore we will use a define Directives.
Define Directives is another way to use System.Diagnostics.Conditional,
#define RELEASE_MODE 
 
using System; 
namespace SystemDiagnosticsUsefulActions 

    class Program 
    { 
        static void Main(string[] args) 
        { 
            ReleaseMethod(); 
 
            Console.Read(); 
        } 
 
        [System.Diagnostics.Conditional("RELEASE_MODE")] 
        public static void ReleaseMethod() 
        { 
            Console.WriteLine("Execute Release Method"); 
        } 
 
    } 
 
}  


These are the useful tips and traps of System.Diagnostics. They become very practical in many cases and I hope you find them useful.

HostForLIFE.eu ASP.NET Core 2.2.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.



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: Insert Data using Uploading Excel file and upload image and set water mark

clock September 28, 2018 11:17 by author Peter

In this blog, I will show you how to Insert Data using Uploading Excel file and upload image and set water mark. Let's write the code below.

Demo.aspx
<body> 
    <form id="form1" runat="server"> 
        <div> 
            <table> 
                <tr> 
                    <td> 
                        <asp:FileUpload ID ="fu" runat ="server" /> 
                    </td> 
                    <td> 
                        <asp:Button ID ="btnupload" runat ="server" Text="Upload File" 
onclick="btnupload_Click" /> 
                    </td> 
                </tr> 
            </table> 
        </div> 
    </form> 
</body> 


Demo.aspx .cs
DataTable dt = new DataTable(); 
 
protected void btnupload_Click(object sender, EventArgs e) 

    if (fu.HasFile) 
    { 
        if (fu.PostedFile.ContentType == "application/vnd.ms-excel" || fu.PostedFile.ContentType == "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") 
        { 
            string fileName = Path.Combine(Server.MapPath("~/localization"), Guid.NewGuid().ToString() + Path.GetExtension(fu.PostedFile.FileName)); 
            fu.PostedFile.SaveAs(fileName); 
 
            string conString = ""; 
            string ext = Path.GetExtension(fu.PostedFile.FileName); 
            if (ext.ToLower() == ".xls") 
            { 
                conString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + fileName + ";Extended Properties=\"Excel 8.0;HDR=Yes;IMEX=2\""; 
            }  
            else if (ext.ToLower() == ".xlsx")  
            { 
                conString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + fileName + ";Extended Properties=\"Excel 12.0;HDR=Yes;IMEX=2\""; 
            } 
            string query = "Select * from [Sheet1$]"; 
            OleDbConnection con = new OleDbConnection(conString); 
            OleDbDataAdapter data = new OleDbDataAdapter(query, con); 
            data.Fill(dt); 
            int i = 0; 
            //File_Upload file = new File_Upload(); 
            for (i = 0; i < dt.Rows.Count; i++) 
            { 
                string name = dt.Rows[i]["name"].ToString(); 
                string email = dt.Rows[i]["email"].ToString(); 
                string pass = dt.Rows[i]["Password"].ToString(); 
                string mobile = dt.Rows[i]["mobile"].ToString(); 
                string state = dt.Rows[i]["state"].ToString(); 
                string city = dt.Rows[i]["city"].ToString(); 
                string photo = dt.Rows[i]["Photo"].ToString(); 
 
                string[] pathArr = photo.Split('\\'); 
                string[] fileArr = pathArr.Last().Split('.'); 
                string fName = fileArr[0].ToString(); 
                Random rnd = new Random(); 
                string fn = fName + "_" + rnd.Next(111, 999) + "_" + rnd.Next(111, 999) + ".jpg"; 
                string path = "~/photo/" + fn; 
                string pat = Server.MapPath(path); 
                Wattermark w = new Wattermark(); 
                Dal odal = new Dal(); 
                System.Drawing.Image image = System.Drawing.Image.FromFile(photo); 
                Graphics graphics = Graphics.FromImage(image); 
                Font font = new Font("Times New Roman", 42.0f); 
                PointF point = new PointF(10, 10); 
                graphics.DrawString("Tusharsangani", font, Brushes.Red, point); 
                image.Save(pat); 
                odal.fetch("insert into Registeruser (name,E_id,password,mobile,state,city,photo) values('" + name + "','" + email + "','" + pass + "','" + mobile + "','" + state + "','" + city + "','" + path + "')"); 
            } 
        } 
    }  
    else  
    { 
 
    } 

HostForLIFE.eu ASP.NET Core 2.2.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.

 



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: Random Password In C#

clock September 26, 2018 11:14 by author Peter

A random password is a combination of characters, numbers, and special characters. We can generate a random password by combining random numbers and random strings.
Generate A Random Password In C# And .NET Core. The code snippet in this article is an example of how to generate random numbers and random strings and combine them to create a random password using C# and .NET Core.

The Random class constructors have two overloaded forms. It takes either no value or it takes a seed value. The Random class has three public methods - Next, NextBytes, and NextDouble. The Next method returns a random number, NextBytes returns an array of bytes filled with random numbers, and NextDouble returns a random number between 0.0 and 1.0.

Generate a random number
The following code in Listing 1 returns a random number.
// Generate a random number 
Random random = new Random(); 
// Any random integer  
int num = random.Next(); 


Generate a random string
The following code snippet in Listing 2 generates a random string with a given size. The second parameter of the RandomString method is used for setting if the string is a lowercase string.
// Generate a random string with a given size and case.  
// If second parameter is true, the return string is lowercase 
public string RandomString(int size, bool lowerCase) 

    StringBuilder builder = new StringBuilder(); 
    Random random = new Random(); 
    char ch; 
    for (int i = 0; i < size; i++) 
    { 
        ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))); 
        builder.Append(ch); 
    } 
    if (lowerCase) 
        return builder.ToString().ToLower(); 
    return builder.ToString(); 


Creating a random password
A random password can simply be a combination of a random string and a random number. To make it more complex, you can even add special characters and mix it up.
For us, we will combine the two methods - RandomNumber and RandomString.

The following code snippet in Listing 3 generates a password of length 10 with first 4 letters lowercase, next 4 letters numbers, and the last 2 letters as uppercase.
// Generate a random password of a given length (optional) 
public string RandomPassword(int size = 0) 

    StringBuilder builder = new StringBuilder(); 
    builder.Append(RandomString(4, true)); 
    builder.Append(RandomNumber(1000, 9999)); 
    builder.Append(RandomString(2, false)); 
    return builder.ToString(); 


All of the above functionality is listed here in Listing 4. Create a .NET Core Console app in Visual Studio and use this code.
using System; 
using System.Text; 
 
class RandomNumberSample 

    static void Main(string[] args) 
    { 
        // Generate a random number 
        Random random = new Random(); 
        // Any random integer  
        int num = random.Next(); 
 
        // A random number below 100 
        int randomLessThan100 = random.Next(100); 
        Console.WriteLine(randomLessThan100); 
 
        // A random number within a range 
        int randomBetween100And500 = random.Next(100, 500); 
        Console.WriteLine(randomBetween100And500); 
 
        // Use other methods  
        RandomNumberGenerator generator = new RandomNumberGenerator(); 
        int rand = generator.RandomNumber(5, 100); 
        Console.WriteLine($"Random number between 5 and 100 is {rand}"); 
 
        string str = generator.RandomString(10, false); 
        Console.WriteLine($"Random string of 10 chars is {str}"); 
 
        string pass = generator.RandomPassword(); 
        Console.WriteLine($"Random password {pass}"); 
 
        Console.ReadKey(); 
    } 

 
public class RandomNumberGenerator 

    // Generate a random number between two numbers   
    public int RandomNumber(int min, int max) 
    { 
        Random random = new Random(); 
        return random.Next(min, max); 
    } 
 
// Generate a random string with a given size and case.  
// If second parameter is true, the return string is lowercase 
public string RandomString(int size, bool lowerCase) 

    StringBuilder builder = new StringBuilder(); 
    Random random = new Random(); 
    char ch; 
    for (int i = 0; i < size; i++) 
    { 
        ch = Convert.ToChar(Convert.ToInt32(Math.Floor(26 * random.NextDouble() + 65))); 
        builder.Append(ch); 
    } 
    if (lowerCase) 
        return builder.ToString().ToLower(); 
    return builder.ToString(); 

 
    // Generate a random password of a given length (optional) 
    public string RandomPassword(int size = 0) 
    { 
        StringBuilder builder = new StringBuilder(); 
        builder.Append(RandomString(4, true)); 
        builder.Append(RandomNumber(1000, 9999)); 
        builder.Append(RandomString(2, false)); 
        return builder.ToString(); 
    } 


The random string and random password looks like Figure 1.
Generate A Random Password In C# And .NET Core


Random password with given characters

Now, let’s say, you want to create a password that allows some specific characters only. The following code snippet in Listing 5 has a string of valid characters. The code uses this string to pick one character at a time for the password and stops at the given length. The default length of the password is 15.

private static string CreateRandomPassword(int length = 15) 

    // Create a string of characters, numbers, special characters that allowed in the password 
    string validChars = "[email protected]#$%^&*?_-"; 
    Random random = new Random(); 
 
    // Select one random character at a time from the string 
    // and create an array of chars 
    char[] chars = new char[length]; 
    for (int i = 0; i < length; i++) 
    { 
        chars[i] = validChars[random.Next(0, validChars.Length)]; 
    } 
    return new string(chars); 


Note
You can modify validChars string with the characters you allowed in the password.
Listing 6 is the complete program written in .NET Core.

using System; 
class Program 

    static void Main(string[] args) 
    {  
        Console.WriteLine(CreateRandomPassword()); 
        Console.WriteLine(CreateRandomPassword(10)); 
        Console.WriteLine(CreateRandomPassword(30)); 
 
        Console.WriteLine(CreateRandomPasswordWithRandomLength()); 
 
        Console.ReadKey(); 
    } 
 
 
    // Default size of random password is 15 
    private static string CreateRandomPassword(int length = 15) 
    { 
        // Create a string of characters, numbers, special characters that allowed in the password 
        string validChars = "[email protected]#$%^&*?_-"; 
        Random random = new Random(); 
 
        // Select one random character at a time from the string 
        // and create an array of chars 
        char[] chars = new char[length]; 
        for (int i = 0; i < length; i++) 
        { 
            chars[i] = validChars[random.Next(0, validChars.Length)]; 
        } 
        return new string(chars); 
    } 
 
    private static string CreateRandomPasswordWithRandomLength() 
    { 
        // Create a string of characters, numbers, special characters that allowed in the password 
        string validChars = "[email protected]#$%^&*?_-"; 
        Random random = new Random(); 
 
        // Minimum size 8. Max size is number of all allowed chars. 
        int size = random.Next(8, validChars.Length); 
 
        // Select one random character at a time from the string 
        // and create an array of chars 
        char[] chars = new char[size]; 
        for (int i = 0; i < size; i++) 
        { 
            chars[i] = validChars[random.Next(0, validChars.Length)]; 
        } 
        return new string(chars); 
    } 

 



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: Start Using HTTP Handlers In ASP.NET

clock September 19, 2018 11:48 by author Peter

First, let me explain the main purpose of using HTTPHandler. Sometimes you need to handle a specific request separately using a different method from that of a normal request. This article will explain HTTP Handler in a simple way. Let’s begin:
How can you handle any incoming HTTP request with a path “AllUsers/User.gif” by returning “Hello From HTTP Handler”.

  • Create a class file --  it could be MyHttpHandler.cs
  • Let MyHttpHandler class inherit from IhttpHandler Interface.
  • In MyHttpHandler class, implement all the methods which are found in IhttpHandler Interface.

You should do the following,
using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Web; 
namespace MyProject { 
    public class MyHttpHandler: IHttpHandler { 
        public bool IsReusable { 
            get { 
                return true; 
            } 
        } 
        public void ProcessRequest(HttpContext context) { 
            HttpResponse response = context.Response; 
            response.Write("Hello From Http Handler"); 
        } 
    } 


The next step is to register the http handler in the web.config,

<httpHandlers> 
   <add verb="*" path="AllUsers/User.gif" type="MyProject.MyHttpHandler,MyProject"/> 
</httpHandlers> 


The above code (point 4) should be added as a child of <system.web>

That's all. Now HTTP Handler is ready

Section2
When using HTTP Handler with either MVC or WEB API, you will get the following error:


Because each MVC and WEB API are using routing to access methods within the controller, they will search the path and find that it is not found. To solve this problem you have two choices:

The first one is,

  • Create a class file --  it could be MyRouteHandler.cs
  • Let MyRouteHandlerclass inherit from IRouteHandlerInterface.
  • In MyRouteHandler class, implement all the methods which are found in IRouteHandlerInterface and return the MyHttpHandlerwhich are created in the previous section.

You should do the following,
public class MyRouteHandler: IRouteHandler { 
    public IHttpHandler GetHttpHandler(RequestContext requestContext) { 
        return new MyHttpHandler(); 
    } 


In RouteConfig class which is related to MVC and WEP API and responsible for requests routing, add the following line code to RegisterRoutes method and before the Default MapRoute.
routes.Add(new Route("AllUsers/User.gif", new MyRouteHandler())); 

Drop the HTTP Handler registration from web.config, since calling HTTP Handler will be from RegisterRoutes method.

The Second Solution Is:

Let us go back to section 1. It is a straightforward solution: In RouteConfig class which is related to MVC and WEP API and responsible for requests routing, add the following line of code to the RegisterRoutes method and before the Default MapRoute.
routes.IgnoreRoute("AllUsers/User.gif"); 

That's it.

Note
If you want to Handle all HTTP requests which have a specific extentaion such as gif you can using the following in web.config.
<httpHandlers> 
   <add verb="*" path="*.gif" type="MyProject.MyHttpHandler,MyProject"/> 
</httpHandlers> 

HostForLIFE.eu ASP.NET Core 2.2.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.



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: How to Unloading Assemblies in C#?

clock September 12, 2018 08:06 by author Peter

If you've created an Application Domain and want to unload all the assemblies loaded within, there is no way to unload Assembly themselves. But you can unload Application Domain you've just created.
 
In addition to that one;
You cannot unload the default Application Domain CLR created on its own. And unloading can differ from the assemblies being used and the unload events these assemblies have. It can take some time.
 
To Unload an Application Domain all you need to do is calling Unload function.
 
A sample code can help you understand:
    AppDomain myDom=AppDomain.Create("Ibrahims Domain"); 
    //Here assuming you loaded your assemblies 
    //To unload AppDomain call Unload Function 
    AppDomain.Unload(myDom); 
    // The Application Domain we've just created is now no more as the assemblies with it. 


After Unloading Application Domain object, we've also unloaded all the assemblies loaded within.

HostForLIFE.eu ASP.NET Core 2.2.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.

 



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: How to Cross Domain ASP.NET Web API Calling Using jQuery AJAX ?

clock September 5, 2018 13:11 by author Peter

If we have made a Restful API utilizing the ASP.NET Core 2.2.1 Web API and if your API is in one space and the UI is in an alternate area then you may get problem because of cross-domain issues. And here is the way:

  • OPTIONS http://localhost:5000/api/ 404 (Not Found).XMLHttpRequest cannot load http://localhost:5000/api/.
  • No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://localhost:54317' is therefore not allowed access. The response had HTTP status code 404.

As it were you can't make a call to the WebAPI by means of your front end that is facilitated on an alternate domain.
So you must utilization JSONP to get information utilizing using AJAX, not by JSON.  To attain to this objective you have to introduce JsonpMediaTypeFormatter. For introducing the JsonpMediaTypeFormatter in Visual Studio, seek JsonpMediaTypeFormatter in "Manage NuGet Packages" and install it.

Next, you can see in your project references that a new DLL was added. WebApiContrib.Formatting.Jsonp.dll

To use this DLL you need to change in the Application_Start() method in the Global.asax.cs file.
using WebApiContrib.Formatting.Jsonp;   
using System.Net.Http.Formatting;   

GlobalConfiguration.Configuration.Formatters.Clear();   GlobalConfiguration.Configuration.Formatters.Add(new JsonpMediaTypeFormatter(new JsonMediaTypeFormatter())); 

You also can use JsonMediaTypeFormatter code, you should write this code in the App_Start folder & register the following code in Application_Start().
JsonMediaTypeFormatter code:
    using System;   
    using System.Collections.Generic;   
    using System.Linq;   
    using System.Web;   
    using System.Net.Http.Formatting;   
    using System.Net.Http.Headers;   
    using System.Net.Http;   
    using Newtonsoft.Json.Converters;   
    using System.IO;   
    using System.Net;   
    using System.Threading.Tasks;   
    namespace WebAPI   
    {   
        /// <summary>   
        /// Handles JsonP requests when requests are fired with text/javascript   
        /// </summary>   
        public class JsonpFormatter : JsonMediaTypeFormatter   
        {   
            public JsonpFormatter()   
            {   
                SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));   
                SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/javascript"));           
                JsonpParameterName = "callback";   
            }   
            /// <summary>   
            ///  Name of the query string parameter to look for   
            ///  the jsonp function name   
            /// </summary>   
           public string JsonpParameterName { get; set; }   
           /// <summary>   
            /// Captured name of the Jsonp function that the JSON call   
            /// is wrapped in. Set in GetPerRequestFormatter Instance   
            /// </summary>   
            private string JsonpCallbackFunction;
            public override bool CanWriteType(Type type)   
            {   
                return true;   
            }           
            /// <summary>   
            /// Override this method to capture the Request object   
            /// </summary>   
            /// <param name="type"></param>   
            /// <param name="request"></param>   
            /// <param name="mediaType"></param>   
            /// <returns></returns>   
            public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)   
            {   
                var formatter = new JsonpFormatter()   
                {   
                    JsonpCallbackFunction = GetJsonCallbackFunction(request)   
                };   
               // this doesn't work unfortunately   
                //formatter.SerializerSettings = GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings;   
                // You have to reapply any JSON.NET default serializer Customizations here       
                formatter.SerializerSettings.Converters.Add(new StringEnumConverter());   
                formatter.SerializerSettings.Formatting = Newtonsoft.Json.Formatting.Indented;           
                return formatter;   
            }                   
           public override Task WriteToStreamAsync(Type type, object value,   
                                            Stream stream,   
                                            HttpContent content,   
                                            TransportContext transportContext)   
            {   
                if (string.IsNullOrEmpty(JsonpCallbackFunction))   
                    return base.WriteToStreamAsync(type, value, stream, content, transportContext);   
                        StreamWriter writer = null;           
                // write the pre-amble   
                try   
                {   
                    writer = new StreamWriter(stream);   
                    writer.Write(JsonpCallbackFunction + "(");   
                    writer.Flush();   
                }   
                catch (Exception ex)   
                {   
                    try   
                    {   
                        if (writer != null)   
                            writer.Dispose();   
                    }   
                   catch { }           
                    var tcs = new TaskCompletionSource<object>();   
                    tcs.SetException(ex);   
                    return tcs.Task;   
                }           
                return base.WriteToStreamAsync(type, value, stream, content, transportContext)   
                           .ContinueWith(innerTask =>   
                           {   
                               if (innerTask.Status == TaskStatus.RanToCompletion)   
                               {   
                                   writer.Write(")");   
                                   writer.Flush();   
                               }   
                               writer.Dispose();   
                               return innerTask;   
                           }, TaskContinuationOptions.ExecuteSynchronously)   
                                .Unwrap();   
            }   
                    /// <summary>   
            /// Retrieves the Jsonp Callback function   
            /// from the query string   
           /// </summary>   
           /// <returns></returns>   
            private string GetJsonCallbackFunction(HttpRequestMessage request)   
            {   
                if (request.Method != HttpMethod.Get)   
                    return null;   
                        var query = HttpUtility.ParseQueryString(request.RequestUri.Query);   
                var queryVal = query[this.JsonpParameterName];   
                        if (string.IsNullOrEmpty(queryVal))   
                    return null;           
                return queryVal;   
            }   
        }   
    } 

Next step, use the following code to make change in the Application_Start() method in the Global.asax.cs file.
GlobalConfiguration.Configuration.Formatters.Insert(0, new WebAPI.JsonpFormatter());


jQuery code to use the Web API:
    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>   
    <script language="javascript" type="text/javascript">   
        function GetInformation() {   
            var apiServicePath = "http://localhost:5000/api/";   
            jQuery.ajax({   
                crossDomain: true,  
                dataType: "jsonp",   
                url: apiServicePath + "test/GetInformation",   
                async: false,   
                context: document.body   
            }).done(function (data) {   
                alert("Done");   
            });   
        };   
    </script> 

 

HostForLIFE.eu ASP.NET Core 2.2.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.

 



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: Mapping Similar Objects In ASP.NET Core 2.0

clock August 20, 2018 11:29 by author Peter

This post is about Automapper. As its name suggests, it will do some sort of mapping. Now, the question is, what sort of mapping? Well, this mapping is all about mapping the properties of two objects with each other. If you have worked on MVC, you must have come across the scenario, where the situation demands you to map properties of the model with the properties of ViewModel. Isn't it a common scenario? So, one way to achieve this is to map each and every property manually with a lot of code, which in turn become very tedious when there are many properties of an object. Another major disadvantage of this approach is it's error-prone.

Hence, Automapper came to rescue. Automapper is an object to object mapping which reduces the manual effort of mapping each property of a class with the same properties of another class. So, let’s start by writing some code and see how it works.

Step 1
First step is to add the required dependency. This can be done either by using UI or by using Nuget package console,

Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection 
if you are using console to add dependency, then on successful installation of the package, the below message will be shown,


Step 2
Get ready with classes which are to be mapped. Here in this case, we have one model class and one ViewModel class as shown below,
public class Contact 
    { 
        public string Name { get; set; } 
        public string SecurityNumber { get; set; } 
        public string Address { get; set; } 
    } 


ContactViewModel

public class ContactViewModel 
    { 
        public string Name { get; set; } 
        public string SecurityNumber { get; set; } 
        public string City { get; set; } 
        public string State { get; set; } 
    } 


Step 3
Create a class which will take care of all the mappings as shown below, by inheriting the profile which is defined in Automapper namespace,
public class MappingEntity:Profile 
    { 
        public MappingEntity() 
        { 
            CreateMap<ContactViewModel, Contact>(); 
        } 
    } 


Step 4
Register this MappingEntity class in Startup class under ConfigureServices method as shown below,
public void ConfigureServices(IServiceCollection services) 
        { 
            services.AddMvc(); 
            services.AddAutoMapper(x => x.AddProfile(new MappingEntity())); 
        } 


Step 5
Final step is to do the changes in Controller class to accomodate this mapping.
public class HomeController : Controller 
   { 
       private readonly IMapper _mapper; 
       public HomeController(IMapper mapper) 
       { 
           _mapper = mapper; 
       } 
 
       public IActionResult Index(ContactViewModel vm) 
       { 
           var contact = _mapper.Map<Contact>(vm); 
           return View(); 
       } 
 
    ... 
  } 

Now, as per the business requirement, the contact object declared in line number 11 can be used. That's all about automapping.

HostForLIFE.eu ASP.NET Core 2.2.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.



ASP.NET Core 2.2.1 Hosting - HostForLIFE.eu :: Using WebApiClient To Call REST APIs In .NET Core

clock August 15, 2018 11:14 by author Peter

In this article, we will discuss an easy way to call our REST APIs in .NET Core. When we call other APIs in .NET Core, HttpClient will be the first choice. And most of us will create a wrapper to make it easy to use. There are many libraries that are based on HttpClient which help us to call REST APIs.

In this article, I will use WebApiClient.

WebApiClient
WebApiClient is an awesome project which help us to call HTTP(S) APIs. For more information, please visit its GITHUB page,

Here I will use WebApiClient.JIT to demonstrate how to use. Let's begin!

Create Some APIs

Here I use ASP.NET Core WebAPI to creat some RESTful APIs.
    [Route("api/[controller]")] 
    public class PersonsController : Controller 
    { 
        // GET: api/persons 
        [HttpGet] 
        public IEnumerable<Person> Get() 
        { 
            return new List<Person> 
            { 
                new Person{Id = 1 , Name = "stewart"}, 
                new Person{Id = 2 , Name = "peter"} 
            }; 
        } 
     
        // GET api/persons/5 
        [HttpGet("{id}")] 
        public Person Get(int id) 
        { 
            return new Person { Id = id, Name = "name" }; 
        } 
     
        // POST api/persons 
        [HttpPost] 
        public Person Post([FromBody]Person person) 
        { 
            if (person == null) return new Person(); 
     
            return new Person { Id = person.Id, Name = person.Name }; 
        } 
     
        // PUT api/persons/ 
        [HttpPut] 
        public string Put([FromBody]int id) 
        { 
            return $"put {id}"; 
        } 
     
        // DELETE api/persons/5 
        [HttpDelete("{id}")] 
        public string Delete(int id) 
        { 
            return $"del {id}"; 
        } 
    } 


Interface Declaration

Create an interface named IPersonApiClient which inherit from IHttpApiClient.
    public interface IPersonApiClient : IHttpApiClient { } 

Add some methods that need to call APIs.
Every method must have a HTTP attribute that provides the request method and relative URL. The return type should be ITask<T>.
    [HttpGet("/api/persons")]   
    ITask<List<Person>> GetPersonsAsync();   

A request URL can be updated dynamically using replacement blocks and parameters on the method. A replacement block is an alphanumeric string surrounded by { and }.
    [HttpGet("/api/persons/{id}")] 
    ITask<Person> GetPersonAsync(int id); 


When our requst parameters should in request body, we can use some attributes to specify the content, such as JsonContent, FormContent .etc.
    [HttpPost("/api/persons")] 
    ITask<Person> AddPersonAsync([JsonContent]Person person);  


The following code demonstrates the basic usage.
    public interface IPersonApiClient : IHttpApiClient 
    { 
        [HttpGet("/api/persons")] 
        ITask<List<Person>> GetPersonsAsync(); 
     
        [HttpGet("/api/persons/{id}")] 
        ITask<Person> GetPersonAsync(int id); 
     
        [HttpPost("/api/persons")] 
        ITask<Person> AddPersonAsync([JsonContent]Person person); 
     
        [HttpPut("/api/persons")] 
        ITask<string> EditPersonAsync([JsonContent]int id); 
     
        [HttpDelete("/api/persons/{id}")] 
        ITask<string> DeletePersonAsync(int id); 
    } 


The next step is how to retrieve the response of the request.
Retrieving Response

We should create a client first. After creating , what we need to do is call the methods we declared in the interface.

    //specify the config 
    var config = new HttpApiConfig 
    {                 
        HttpHost = new Uri("http://localhost:9999"), 
    }; 
     
    var client = HttpApiClient.Create<IPersonApiClient>(config); 
     
    var persons = await client.GetPersonsAsync(); 
     
    Console.WriteLine("GetPersonsAsync result:"); 
    foreach (var item in persons) 
    { 
        Console.WriteLine($"{item.Id}-{item.Name}"); 
    } 
     
    var person = await client.GetPersonAsync(1000); 
    Console.WriteLine("GetPersonAsync result:"); 
    Console.WriteLine($"{person.Id}-{person.Name}"); 
     
     
    var newPerson = new Person { Id = 999, Name = "999" }; 
    var postResult = await client.AddPersonAsync(newPerson); 
    Console.WriteLine("AddPersonAsync result:"); 
    Console.WriteLine($"{postResult.Id}-{postResult.Name}"); 
     
     
    var editResult = await client.EditPersonAsync(1); 
    Console.WriteLine("EditPersonAsync result:"); 
    Console.WriteLine($"{editResult}"); 
     
    var delResult = await client.DeletePersonAsync(1); 
    Console.WriteLine("DeletePersonAsync result:"); 
    Console.WriteLine($"{delResult}");

HostForLIFE.eu ASP.NET Core 2.2.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.

 



About HostForLIFE.eu

HostForLIFE.eu is European Windows Hosting Provider which focuses on Windows Platform only. We deliver on-demand hosting solutions including Shared hosting, Reseller Hosting, Cloud Hosting, Dedicated Servers, and IT as a Service for companies of all sizes.

We have offered the latest Windows 2016 Hosting, ASP.NET Core 2.2.1 Hosting, ASP.NET MVC 6 Hosting and SQL 2017 Hosting.


Tag cloud

Sign in