At this point we’ve all heard of Blazor. But when people first start out with Blazor, the analysis paralysis of picking between the types of Blazor projects can keep people from picking it up quickly—and being able to quickly dive in and have something up and running is one of the primary benefits of using Blazor in the first place.

My hope with this article is to provide a simple understanding of the differences between Blazor Server and Blazor WebAssembly, and give you the knowledge to pick the right tool for the job.

Both Blazor project types use the same component-based structure for writing web applications. If you’ve ever used React, you’ll understand what this looks like. Each unit of work or piece of UI is broken up into individual components, and components can be composed together as bigger, more complex components. In Blazor, we write these as Razor Components (.razor) which allows us to weave HTML and C# within the same code file. It’s great to work with and allows for very dynamic and maintainable UI components.

Blazor Server or WebAssembly. Which one is better?

This question gets asked a lot, but when it comes down to it, it’s not really the right question to ask. They are both amazing in their own regard, but it’s important to understand that they are very different fundamentally. A better question to ask is, “Which one is better for my situation?”

Blazor Server
Blazor Server, at its heart, is an ASP.NET Core server-side web app. The entire application runs on the server and the pages/components are rendered on the server before being sent as HTML to the client.

Blazor Server is very unique, and to my knowledge is the first technology to do things the way it does.

When a user connects to your Blazor Server web app, a SignalR connection is established between the client and the server. Every UI interaction from the user is sent as a small packet via this SignalR connection to the server. Every update or redraw of the UI is sent by the server to the client via SignalR.

This connection is maintained throughout the entire session, and if the connection is broken for any reason (exceptions/errors, connection issues, server restarts, etc) the user must refresh the page to re-establish the SignalR connection—otherwise the app will not be functional.

This is a very unique approach to web development. It allows us to make highly dynamic, flexible and responsive Single-Page-Applications (SPAs) that are entirely server-side applications.

Pros

• Data access is simpler. You do not need complicated API authentication schemes and session security to handle data access within your application. This is a server-side app after all, you can use an internal API or just use the Repository Pattern directly within your Blazor project.

• The code is processed on the server before the client machine gets any code, so they do not have access to the C# code from the browser. This again makes security, authorization, and data access much simpler endeavors
• Because of the previously mentioned points, Blazor Server is very easy to work with. You can jump in and work on your application very quickly and without many roadblocks.

These are very big benefits to consider. As a developer you can write a very feature-rich app quickly, while still following best practices.

Cons

• As previously mentioned, a SignalR connection is maintained for each individual client connected to the web app. These connections have a slight overhead on the server and can start to get expensive at large scale. If your application must support a very large number of concurrent users, it’s definitely something to consider. (Most applications will not see the kind of scale where this will matter.)

• Since UI interactions are reliant on a socket connection between the client and server, latency due to poor internet connection or physical distance from the server can negatively affect the experience of the user. Users with high latency may experience a noticeable lag in the UI interactions or will have a generally unpleasant experience. If your application will have a very diverse global reach, this will be something to consider.

Blazor WebAssembly

Blazor WebAssembly works very differently than Blazor Server. The entire application, along with its components and dependencies, are sent to the client. A very light-weight version of the .NET Runtime is also sent to the client. The Blazor application is then run entirely by the client’s browser with the help of WebAssembly.

This model of execution allows for a very pleasant user experience, since the UI interaction is not at all dependent on a persistent connection to the server. The client’s machine is doing all the work, so there is no server load to speak of when it comes to serving up the app to a user. In fact, you can even host a Blazor WebAssembly app entirely as a static website on a service such as Netlify, GitHub Pages, Azure Static Web Apps, etc. without writing a dedicated web server.

Pros

• Scale. Blazor WebAssembly apps can achieve arbitrary scale because the server is not running the application, the client is. This model allows for scaling to a high amount of concurrent users cheaply.
• Blazor WebAssembly apps can work offline or be written as PWAs (Progressive Web Apps)
• Performance is generally very good and offers a great user experience because the application is running on the client’s machine as opposed to a server
• Since you don’t need a dedicated server running and maintaining active user sessions, hosting a Blazor WebAssembly application can have a significantly lower cost.

Cons

• Data access and security is more complicated, since this application will be running entirely on the client side. All data access must be done over public APIs, which means that if you have user-specific or session-specific data, then the API auth and security must be managed. Additionally, the client will have access to your code (which is true of all client-side web frameworks) so you have to be aware of this while developing your app.
• Relatively big download size for the user. Initial app load time may take longer while the client’s machine downloads all the necessary files for the application to run. This isn’t unique to Blazor however and it’s somewhat common among front-end web frameworks to be a bit heavily front-loaded.
• WebAssembly is not supported by all browsers. It is a W3C standard so all modern standard-compliant browsers do have support or will be including support, but legacy browsers will not support this technology.

Summary

There are many more points to consider with each project type, as Blazor is very complex and full of nuance. But hopefully this article will provide a fundamental overview of both project types and what you should consider about each of them.

To summarize, you should consider picking Blazor Server for:

• Intranet/internal applications
• Apps that don’t expect to have a massive concurrent user-base
• Apps where you want to have the full support of a .NET Core server behind it, and all the tools and features you get with it

And Blazor WebAssembly for:

• Apps that expect to have very large scale with lots of concurrent users
• Apps that can be used offline or with an intermittent connection
• Apps where performance might be a concern / users might be accessing your app from different parts of the world

Hope this information has been helpful. Stay safe and happy coding!

Node.js was created by Rayn Dahl in 2009 and his work was supported by Joyent. The core idea behind its development was extending Javascript into something that can not only run in the browser but also operate on the machine as a standalone application.
 
What can Node.JS do? Can you use it to build your first highly-secured application?
 
If you are asking these questions, then you are in the right place. Today, we are going to inform you why there’s so much hype among the developers when it comes to Node.js.
 
With so many technologies for development, it can be tough to choose the one which you can easily master yet it can give you better results. Besides, as a beginner, it’s way tougher to choose. So why should you go for Node.js? What makes it so special? Let’s get started from the basics.
 
Node.js was created by Rayn Dahl in 2009 and his work was supported by Joyent. The core idea behind its development was extending Javascript into something that can not only run in the browser but also operates on the machine as a standalone application.
 
Along with Javascript, Node.js runs on the specific Javascript runtime engine, i.e., V8. This runtime engine takes your code from Javascript and transforms it into rapid machine code.
 
Besides, several top-notch apps like Uber, PayPal, Netflix, etc. state that Node.js has powered their web applications and has provided a much faster interface.
 
Why Node.js?
 
Node.js is a Javascript runtime environment that promotes open-source and cross-platform functionalities. It helps in the execution of Javascript outside a browser. With the help of Node.js, one can create a dynamic web application or web page by writing and running a command-line for server-side scripting before the page is being shared at the user’s end.
 
It provides a unique blend of helpers, libraries, and other tools that make the web app development process efficient, easier, and simpler to operate. Besides, it offers a powerful base to develop web apps while securing an online presence.
 
Node.js uses a non-blocking, event-driven I/O Model that turns it light and efficient. It has one of the largest open-source libraries ecosystems, NPM. Besides, it uses push technology on web sockets that allows 2-way communication between server and client. One of the perfect examples of this feature of Node.js is Chatbots. You might have come across one of those while visiting a website’s customer service as well.
 
So now that you have a clear understanding of what you can do with Node.js, let’s get to the details that make it astounding!
 
Reasons that Make Node.js Exceptional!
 
Fast & Scalable
The scalability that Node.js provides to an organization has boosted their profits. As we have already discussed that Node.js runs on V8, its speed in terms of computing is unbeatable. With the new JS code conversion into the native language, the outcoming speed of operation has inspired several large and small institutions.
Besides, Node.js can help you with its ability to run a large batch of asynchronous processes simultaneously. Unlike other technologies for development, Node.js can complete reading, writing, or modifying a database in a shorter timeline.
 
Supremely Extensible
Another vital feature of Node.js is its extensibility. According to the requirements you have, the capabilities it has can be constructed and extended. For any developer who wants to share data among the web server and client, Node.js is there for your aid. It saves the coder from modulating differences in syntax while writing for the backend.
 
Easy To Learn & Code
From the very beginning, Javascript has been introduced in the coding world. It has improved and evolved itself with the internet. That means, almost every programmer or developer has a little bit of Javascript knowledge. But for those who don’t know what the heck is Javascript, it’s the basic and simple language that anyone can efficiently learn in minimum time.
 
As the V8 engine is created for JS coding and deployment by Google Chrome, it makes your work problem-free, and easy. So to get fabulous deployment results, all you need to do is code with JS along with Node.js and your stunning web-app is on its way!
 
Enhanced Productivity
Being entirely based on Javascript, Node.js removes the requirement for having different developers. Be it front-end or back-end, you can easily do it with Node.js instead of relying on other programming languages to complete the task which in return increases productivity.
 
Pervasive Runtime
With the arrival of Node.js, Javascript has been freed from the limitation of the environment as well. Now you can use JS on the client-side along with the server-side.
 
Regardless of where you are manipulating with the files, the effects can easily be seen on the other side.
 
Data Streaming
When it comes to Data Streaming, Node.js can effectively handle both input and output requests to support the online streaming functionality. It uses data streams to run certain operations at the same time it processes data.
 
Single Codebase
As you can write code in JS on both server and client-side, Node.js makes code execution and deployment faster and easier. Moreover, as language conversion is not required in Node.js, the data can be easily transferred from client to server and vice-versa.
 
NPM
NPM or Node.js Package Module enables different environmental packages to indulge into the existing one. It makes the development and performance robust, consistent, and quicker. There are more than 6000 modules available in Node.js that competes with ruby and will soon surpass it.
 
Database Query Resolutions
With Node.js working for both front-end and back-end, there is no need for you to worry about the translation of codes which also promotes flawless streaming while easily solving the database queries by itself.
 
Proxy Server
Node.js acts like a proxy server that gathers data resources and gives the third-party app enough time to perform the requested/required actions.
 
Conclusion
Node.js comes with plenty of benefits which makes it an adequate choice for developing a web application. While using it in your next project, you can not only assure less turnaround time, but also ensure an amazing output level.
 
If you want to empower yourself as a developer and you want the user of your web application to utilize the application to its highest extent in order to yield desirable outcomes, then Node.js is an ideal alternative.
 
Overall, it would not be wrong to say that Node.js has become the first choice for web app developers. There are several reasons Node.js has flourished so much and will undoubtedly reach great heights in the application development industry. It gives you what you want so you can offer creative solutions.

In this article we will observe uploading a file on a web server made use Node.js. Stream in Node.js makes this task super simple to upload files or so far as that is concerned working with any information exchange between a server and a client. To transfer a file we will work with two modules, HTTP and fs. So let us begin with stacking these two modules in an application:

var http = require('http');
var fs = require('fs')

When modules are loaded proceed to and make a web server as below:
http.createServer(function(request,response){   
  }).listen(8080);

So far we are great and now we wish to utilize the accompanying procedure:
Make a destination write stream. In this stream the substance of the uploaded file will be written. We need to compose once again to the client the rate of data being uploaded.

The first requirement could be possible utilizing a pipe. A pipe is an event of stream in Node.js. And the request is a readable stream. So we will use a pipe event to write a request to a readable stream.
var destinationFile = fs.createWriteStream("destination.md");     
      request.pipe(destinationFile);

The second necessity is to give back an of data uploaded. To do that first read the aggregate size of the file being uploaded. That could be possible by reading the content-length (line number 1 in the accompanying code snippet). At that point in the data occasion of request we will update uploadedBytes that starts at zero (line number 2). In the data event of the request we are calculating the percentage and writing it back in the response.

Now, It’s time to putting it all together your app should contain the following code to upload a file and return the percentage uploaded.
var http = require('http');
var fs = require('fs');
  http.createServer(function(request,response){    
    response.writeHead(200);
      var destinationFile = fs.createWriteStream("destination.md");      
      request.pipe(destinationFile);
      var fileSize = request.headers['content-length'];
      var uploadedBytes = 0 ;
      request.on('data',function(d){  
          uploadedBytes += d.length;
          var p = (uploadedBytes/fileSize) * 100;
          response.write("Uploading " + parseInt(p)+ " %\n");
     });
      request.on('end',function(){
            response.end("File Upload Complete");
          });
    }).listen(8080,function(){        
        console.log("server started");
         });

On a command prompt start the server as in the picture below:

Presently let us utilize curl -upload-file to upload a file on the server.

As you see, while the file is being uploaded the percentage of data uploaded is returned once again to the client. So thusly you can upload a file to the server made utilizing Node.js. Hope this tutorial works for you!

Binding is basically the process of connecting data between the view of your application and it's code behind.
In Angular, the view of the application is the HTML page and the code behind is the Component class written in typescript code.
 
There are different types of data binding in Angular,
 
Component to View using interpolation
This is one of the ways of bindings provided by the Angular framework. For this one, we need to have a class level property in our Component class which we use in our HTML using double curly braces.
 
For example, the below code snippet shows a piece of code in the component class. There are 3 properties: department, imgURL and
showspinner, out of which imgURL and showspinner are already initialized, whereas department is just declared.
    department: Any;  
    imgURL: string = "assets/photos/Department.jpg";  
    showSpinner: boolean = false;   

In our HTML file, these properties are used inside double curly braces to render these values directly on the browser. In our case, the imgURL represents the source of the image so that has to be used in the below manner, as shown in the below code snippet.
    <image src = {{imgURL}} >  

When the application gets rendered on the browser, {{imgURL}} gets replaced by assets/photos/Department.jpg.
 
In the real time application, this property is initialized dynamically at runtime.
 
Component to View using property binding
Just like interpolation, this is another type of one way binding. Just like the prior one, in property binding also, we need a class level property that has to be bound with an HTML control on the View. However, the syntax is a little different.
 
Let's use the same example to apply to property binding.
    department: Any;  
    imgURL: string = "assets/photos/Department.jpg";  
    showSpinner: boolean = false;  

To use the property binding we need to use the below syntax. We need to enclose the property of the HTML control inside the square braces and enclose the Component property inside the quotes.
    <image [src] = 'imgURL' >  

Note
While rendering the data on UI, interpolation converts the data into string, whereas property binding does not change the type and renders it as it is.
 
View to Component using event binding
 
This type of binding is used to bind data from View to Component i.e. from the HTML page to the Component class. This one is similar to the events of simple javascript. It can either be a simple click event, a keyup, or any other. The only difference is that the events in Angular have to be put inside circular braces, the rest all is same.
 
As shown in the below code snippet, there are 3 buttons with their respective click events. The methods handling those events are in the code behind file.
    <button (click) = 'addDepartment()' >Add </button>  
    <button (click) = 'editDepartment()' >Edit </button>  
    <button (click) = 'deleteDepartment()' >Delete </button>  

To Bind View and Component Simultaneously (two-way binding)
 
This type of binding is a little different from other frameworks. The two-way binding keeps the property in the Component class and the value of the HTML control in sync. Whenever we change the value of HTML control, the value of the property of the Component class also
changes.
 
To implement this type of binding in Angular, we use a special directive with a little bit different of a syntax.
    <input required [(ngModel)] = 'departmentName' name = 'departmentName' >  

As you can see in the above code snippet, a directive ngModel has been used inside 2 types of braces. The two braces signify two different bindings. The square brace is for property binding that we discussed as the second type and the circular is for event binding, the third one
that we discussed.
 
Lets talk a little about this textbox, whenever there is any change in the value of this textbox an event gets triggered, and by means of the event binding the value gets passed to the Component property and it gets updated and similarly whenever there is any change in the property value, the value of the textbox will also get updated by means of property binding.

The Component property associated with this textbox in the above code is departmentName.
 
Take an example, when we are fetching some data by making an API call, at the beginning the textbox won't have any value but as soon as the value of the property in the Component class gets updated, the value of textbox will also get updated simultaneously.
 
Note
In order to use [(ngModel)] for two-way binding, the name attribute is a must. The Angular framework internally uses the name attribute to map the value of HTML control with the Component property.

HostForLIFE.eu AngularJS Hosting
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 customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

In this post, let me explain you how to create strong password for AngularJS. For choosing a password we need combination of special characters, Capital letter , small letters, digits etc to make it strong. Write the following code:

    <!DOCTYPE html> 
    <html> 
    <head> 
        <title>Strong Password for Angular UI Pages</title>            
        <script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.3.8/angular.min.js"></script>   
        <script> 
            var app = angular.module("myApp", []); 
            app.controller("myCtrl", function ($scope) {        
                var strongRegularExp = new RegExp("^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,})");        
                var mediumRegularExp = new RegExp("^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9])))(?=.{6,})");        
                $scope.checkpwdStrength = { 
                    "width": "150px", 
                    "height": "25px", 
                    "float": "right" 
                };        
                $scope.validationInputPwdText = function (value) { 
                    if (strongRegularExp.test(value)) { 
                        $scope.checkpwdStrength["background-color"] = "green"; 
                        $scope.userPasswordstrength = 'You have a Very Strong Password now'; 
                    } else if (mediumRegularExp.test(value)) { 
                        $scope.checkpwdStrength["background-color"] = "orange"; 
                        $scope.userPasswordstrength = 'Strong password, Please give a very strong password';  
                    } else { 
                        $scope.checkpwdStrength["background-color"] = "red"; 
                        $scope.userPasswordstrength = 'Weak Password , Please give a strong password'; 
                    }                  
};        
           }); 
        </script> 
    </head> 
    <body ng-app="myApp"> 
        <div ng-controller="myCtrl" style="border:5px solid gray; width:800px;"> 
            <div> 
                <h3>Strong Password for Angular UI Pages </h3> 
            </div> 
            <div style="padding-left:25px;">                  
<div ng-style="checkpwdStrength"></div> 
                <input type="password" ng-model="userPassword" ng-change="validationInputPwdText(userPassword)" class="class1" /> 
                <b> {{userPasswordstrength}}</b> 
            </div> 
            <br /> 
            <br /> 
            <br /> 
        </div> 
    </body> 
    </html> 

HostForLIFE.eu AngularJS Hosting
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 customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

In this article, we are going to learn how to make custom Alert Message with Ajax. Some time we needed to make clone of windows alert message, however that alert message isn't permitting to change the header text. Here using Ajax model popup extender i'll show you how to make custom message box:
Add the user control file and ajaxtoolkit reference in your project.

Write the following code in ascx file.
<style type="text/css">
.MessageBoxPopUp
{
background-color:White;
border:solid 2px #99B4D1;
}

.MessageBoxButton
{
background-color: #A0A0A0;
border: solid 2px #B4B4B4;
color: Black;
font-weight:bold;
font-family:Verdana;
font-size:9pt;
cursor:pointer;
height: 20px;
width:70px;
display:none;
}
.MessageBoxHeader
{
height:17px;
font-size:10pt;
color:White;
font-weight:bold;
font-family:Verdana;
text-align:Left;
vertical-align:middle;
padding:3px 3px 3px 3px;
background-color:#3399FF;
border-bottom:2px solid #B4B4B4;
}
.MessageBoxData
{
height:20px;
font-size:8pt;
font-family:Verdana;
color:#3A4349;
text-align:Left;
vertical-align:top;
}
</style>
<script type="text/javascript">
function closeModelPopup(btn) {
// var mpe = document.getElementById("<%= mpeMessageBox.ClientID %>");
$find('mpeFirmMessageBox').hide();
}
</script>

<cc1:ModalPopupExtender ID="mpeMessageBox" runat="server" DynamicServicePath="" Enabled="True"
TargetControlID="btnTemp" PopupControlID="pnlMessageBox" BackgroundCssClass="modal"
PopupDragHandleControlID="pnlMessageBox" CancelControlID="btnCancel" BehaviorID="mpeFirmMessageBox">
</cc1:ModalPopupExtender>

<asp:Panel ID="pnlMessageBox" runat="server" Style="display: none; width: 300px;
height: 140px;" class="MessageBoxPopUp">
<table border="0" cellpadding="0" cellspacing="0" width="100%">
<tr class="MessageBoxHeader" style="height: 17px;">

<td colspan="2">
    <asp:Label ID="lblHeader" runat="server"></asp:Label>
</td>

<td align="right" style="padding: 2px 2px 0px 0px;">
    <%--<asp:UpdatePanel ID="upnCloseMessageBox" runat="server">
        <ContentTemplate>--%>
            <asp:ImageButton ID="imgBtnClose" runat="server" ImageUrl="~/Image/close_icon.png"
                 OnClientClick="closeModelPopup(this)" />
        <%--</ContentTemplate>
    </asp:UpdatePanel>--%>
</td>
</tr>

<tr>
<td colspan="2" style="height: 5px;">
</td>
</tr>
<tr style="height: 88px;">

<td style="vertical-align: top; padding-left: 5px;">
    <asp:Image ID="imgInfo" runat="server" ImageUrl="~/Image/information-balloon.png" Width="40px" />
</td>

<td class="MessageBoxData" colspan="2" style=" padding: 10px 5px 5px 5px;">
    <asp:Label ID="lblMessage" runat="server"></asp:Label>
</td>

</tr>
<tr style="vertical-align: bottom; height: 20px; padding: 0px 5px 5px 0px;">
<td style="width: 40px;">
</td>
<td align="right" style="width: 180px">
    <asp:Button ID="btnOk" runat="server" CssClass="MessageBoxButton" />
</td>

<td align="right">
    <asp:Button ID="btnCancel" runat="server" CssClass="MessageBoxButton" />
</td>
</tr>
</table>
</asp:Panel>

Now, add the following code in .cs file
public delegate void delegate_OkClick();
public event delegate_OkClick OnOkClick;
public string Header
{
set { lblHeader.Text = value; }
//set { lblHeader.InnerHtml = value; }
}

public string Message
{
set { lblMessage.Text = value; }
}

public Button CancelButton
{
get { return btnCancel; }
}

public Button OkButton
{
get { return btnOk; }
}

public AjaxControlToolkit.ModalPopupExtender MessageBox
{
get { return mpeMessageBox; }
}

protected void Page_Load(object sender, EventArgs e)
{
}

protected void btnOk_OnClick(object sender, EventArgs e)
{
//raise the event if not null
if (OnOkClick != null)
OnOkClick();
}
public void displayMessage(string message)
{
displayMessage(message, null);
}
public void displayMessage(string message, int? type)

{

lblHeader.Text = "Alert Message";
//lblHeader.InnerHtml = title;
lblMessage.Text = message;
btnCancel.Attributes["style"] = "display:block";
btnCancel.Text = "Ok";
mpeMessageBox.Show();
}

Your message box is ready, now you need to call from the aspx page where ever you need to show the message.
You need to add below line of code in
<%@ Register Src="~/Control/Alert.ascx" TagName="MessageBox" TagPrefix="mb" %>
<asp:ScriptManager runat="server" ID="s"></asp:ScriptManager>
<mb:MessageBox ID="ucMessageBox" runat="server"></mb:MessageBox>

And from the code behind cal the display message write the following code:
protected void btnClick_OnClik(object sender, EventArgs e)
{
ucMessageBox.displayMessage("Alert from Code");
}

HostForLIFE.eu AJAX Hosting
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 customers from around the globe, spread across every continent. We serve the hosting needs of the business and professional, government and nonprofit, entertainment and personal use market segments.

What is WCF?
WCF stands for ‘Windows Communication Foundation’. It is a Microsoft platform for building distributed and interoperable applications.

What is a distributed application?
A distributed application is an application where part of it runs on two or more computer nodes. Distributed applications are called ‘Connected systems’ also.

Now, let us see the above diagram where a Windows application is stored on one computer and the web service that it is consuming is running on another computer (which can be situated anywhere in the world). Well, this is a connected system.

Why build distributed applications?
    Interdependency
    An enterprise application may need to use the service provide by other enterprise, For example, an ecommerce application using Paytm for payments.

    For better scalability
    Scalability of an application implies the number of visitors an application can handle without degrading the performance. We can break down the application into different layers that run on different computers. Each of these computers will have its own memory and processor, which helps with improving the scalability of the application.

What is an interoperable application?
An application that can communicate with any other application that is built on any platform is called an interoperable application. Web Services can communicate with any application built on any platform, whereas .NET remoting service can be consumed only by another .NET application.

Why should we use WCF?

Without WCF,

Consider a situation where we have 2 clients and we need to implement a service for them.

The first client is using a Java application to interact with our services. This client wants a message to be in XML format and the protocol to be in HTTP. Without WCF, to satisfy the first client requirement, we will have to create an ASMX web service.

The second Client is using .NET and for better performance, this client wants a message format in binary format and protocol to be in TCP. Without WCF, to satisfy the second client requirement, we will create a .NET Remoting service.

.NET remoting and ASMX are two different technologies, and have completely different programming models. Therefore, developers have to learn two different technologies, which is not only time and cost consuming but needs two people with expertise.

So to unite and bring all these communication technologies under one roof, Microsoft has come up with a single programming model that is called WCF. WCF is going to unify everything, such as .NET Remoting, IPC, MSMQ queue, TCP, Peer networking, and all other communication technologies we have.

With WCF
With WCF, for both the clients, we will implement only one service and to satisfy the requirement of different clients, we will configure different end points.

What Is WCF? Why Should We Use WCF?
Here, the first endpoint will transport a message in XML format over HTTP protocol and the second endpoint will transport the message in binary format over TCP protocol. Here, we don’t need to change the service code to configure these endpoints. Now, if we have a third client who needs a binary message over HTTP protocol, to satisfy that client requirement, all we need to do is to create a new endpoint.

So, we have a single service but then to satisfy the requirements of different clients, we are creating/configuring different endpoints.

This tutorial is for beginners or students. I created a functionality to add, edit and delete a record in PHP with MVC logic without Framework. Also,  explained how to create an MVC pattern in PHP. I hope it will be helpful for you to add a data table in your program.

Building Our MVC Framework Pattern in PHP
You might be wondering why we would even need to create our own framework when there are already so many good choices out there. The reason for this is so that we can gain an understanding of the underlying principles of MVC.

As we learn more about these principles, we will grow in our understanding of why the excellent MVC frameworks do things the way they do. We are not learning how to create an application in Zend Framework, or in CakePHP. We are learning how MVC works, and by extension, how these frameworks have built upon (or deviated from) the way in which we would expect an MVC framework to be built.
Section 1

Config.php is used to connect the mysql database to create a connection parameter for mysql host,user,password and database name.
<?php 
class config   
{    
function __construct() { 
$this->host = "localhost"; 
$this->user  = "root"; 
$this->pass = "welcome"; 
$this->db = "mydb13"; 
} 
} 
?> 

A small part of the code in index.php is used to setup a controller object and call mvcHandler() to view the default page list.php.
<?php 
session_unset(); 
require_once  'controller/sportsController.php';         
$controller = new sportsController();    
$controller->mvcHandler(); 
?> 

In the model folder, create one class for table structure, its named sports and has field and message field to hold messages and data.
<?php 
class sports 
{ 
// table fields 
public $id; 
public $category; 
public $name; 
// message string 
public $id_msg; 
public $category_msg; 
public $name_msg; 
// constructor set default value 
function __construct() 
{ 
$id=0;$category=$name=""; 
$id_msg=$category_msg=$name_msg=""; 
} 
} 
?> 

Section 2
The second section is a sportsModel class structure. We are going to explain and show insertRecord(), updateRecord(),selectRecord() and insertRecord(). The sportsModel class is used to access the function sportsController. The sportsModel class constructor receives a mysql connection parameter to work with the database.
<?php 

class sportsModel 
{ 
// set database config for mysql 
function __construct($consetup) 
{ 
$this->host = $consetup->host; 
$this->user = $consetup->user; 
$this->pass =  $consetup->pass; 
$this->db = $consetup->db;                                 
} 
// open mysql data base 
public function open_db() 
{ 
$this->condb=new mysqli($this->host,$this->user,$this->pass,$this->db); 
if ($this->condb->connect_error)  
{ 
die("Erron in connection: " . $this->condb->connect_error); 
} 
} 
// close database 
public function close_db() 
{ 
$this->condb->close(); 
} 
// insert record 
public function insertRecord($obj){ } 
//update record 
public function updateRecord($obj){ } 
// delete record 
public function deleteRecord($id){ }    
// select record      
public function selectRecord($id){ } 
} 

?> 

Section 3
Section 3 is the controller code part. The sportsController has mvcHandler() and the CRUD functions insert(), update(),delete() and list(). mvcHandler() receives request and execute. This request shows views according to call request by user.
// insert record 
public function insertRecord($obj) 
{ 
try 
{    
    $this->open_db(); 
    $query=$this->condb->prepare("INSERT INTO sports (category,name) VALUES (?, ?)"); 
    $query->bind_param("ss",$obj->category,$obj->name); 
    $query->execute(); 
    $res= $query->get_result(); 
    $last_id=$this->condb->insert_id; 
    $query->close(); 
    $this->close_db(); 
    return $last_id; 
} 
catch (Exception $e)  
{ 
    $this->close_db();    
    throw $e; 
} 
} 
//update record 
public function updateRecord($obj) 
{ 
try 
{    
    $this->open_db(); 
    $query=$this->condb->prepare("UPDATE sports SET category=?,name=? WHERE id=?"); 
    $query->bind_param("ssi", $obj->category,$obj->name,$obj->id); 
    $query->execute(); 
    $res=$query->get_result();                        
    $query->close(); 
    $this->close_db(); 
    return true; 
} 
catch (Exception $e)  
{ 
    $this->close_db(); 
    throw $e; 
} 
} 
// delete record 
public function deleteRecord($id) 
{    
try{ 
    $this->open_db(); 
    $query=$this->condb->prepare("DELETE FROM sports WHERE id=?"); 
    $query->bind_param("i",$id); 
    $query->execute(); 
    $res=$query->get_result(); 
    $query->close(); 
    $this->close_db(); 
    return true;     
} 
catch (Exception $e)  
{ 
    $this->closeDb(); 
    throw $e; 
}        
}    
// select record      
public function selectRecord($id) 
{ 
try 
{ 
    $this->open_db(); 
    if($id>0) 
    {    
        $query=$this->condb->prepare("SELECT * FROM sports WHERE id=?"); 
        $query->bind_param("i",$id); 
    } 
    else 
    {$query=$this->condb->prepare("SELECT * FROM sports");    }        
     
    $query->execute(); 
    $res=$query->get_result();    
    $query->close();              
    $this->close_db();                 
    return $res; 
} 
catch(Exception $e) 
{ 
    $this->close_db(); 
    throw $e;    
} 
 
} 

Section Four
Section four is the view part, when mvcHandler() receives a request and executes the request, it shows views for user. We have created three views in the view folder, which is insert, update and list, which all have HTML design. These views work with controller, and the controller works with model to get or set records in a database table.
<div class="wrapper">   
<div class="container-fluid">   
<div class="row">   
<div class="col-md-12">   
    <div class="page-header clearfix">   
        <a href="index.php" class="btn btn-success pull-left">Home</a>   
        <h2 class="pull-left">Sports Details</h2>   
        <a href="view/insert.php" class="btn btn-success pull-right">Add New Sports</a>   
    </div>   
    <?php   
        if($result->num_rows > 0){   
            echo "<table class='table table-bordered table-striped'>";   
                echo "<thead>";   
                    echo "<tr>";   
                        echo "<th>#</th>";                                           
                        echo "<th>Sports Category</th>";   
                        echo "<th>Sports Name</th>";   
                        echo "<th>Action</th>";   
                    echo "</tr>";   
                echo "</thead>";   
                echo "<tbody>";   
                while($row = mysqli_fetch_array($result)){   
                    echo "<tr>";   
                        echo "<td>" . $row['id'] . "</td>";                                           
                        echo "<td>" . $row['category'] . "</td>";   
                        echo "<td>" . $row['name'] . "</td>";   
                        echo "<td>";   
                        echo "<a href='index.php?act=update&id=". $row['id'] ."' title='Update Record' data-toggle='tooltip'><i class='fa fa-edit'></i></a>";   
                        echo "<a href='index.php?act=delete&id=". $row['id'] ."' title='Delete Record' data-toggle='tooltip'><i class='fa fa-trash'></i></a>";   
                        echo "</td>";   
                    echo "</tr>";   
                }   
                echo "</tbody>";                               
            echo "</table>";   
            // Free result set   
            mysqli_free_result($result);   
        } else{   
            echo "<p class='lead'><em>No records were found.</em></p>";   
        }   
    ?>   
</div>   
</div>           
</div>   
</div>   

Conclusion
This article showed and explained to beginners how to make an MVC framework pattern in PHP. You might be wondering why we would even need to create our own framework when there are already so many good choices out there. The reason for this is so we can gain an understanding of the underlying principles of MVC.