Forem: Janki Mehta

Why .NET is Poised for Massive Growth in 2024

Janki Mehta — Thu, 25 Jan 2024 04:42:27 +0000

The .NET development framework has been around for over 20 years now, first released by Microsoft in 2002. Over this time, it has evolved significantly from early versions like .NET 1.0 and .NET 2.0 to the latest iterations of .NET 6 and beyond. As the framework has matured and added new capabilities, more developers and businesses have adopted it for web, desktop, mobile, and cloud applications.

Looking ahead to 2024, Increasing demand for .NET development skills from both developers and employers is projected to continue increasing for several key reasons:

Cross-Platform Support

One of the biggest changes for .NET in recent years has been the shift to fully support cross-platform development. In the past, .NET was seen as tightly coupled to Windows. However, with .NET Core in 2016 and .NET 5 released in 2020, developers can now build .NET applications targeting Windows, Linux, macOS, iOS, and Android from the same codebase.

This cross-platform capability has opened up .NET to a much wider audience of developers who may have previously avoided it due to platform lock-in concerns. It also allows businesses using a variety of operating systems in their infrastructure to leverage .NET developers more easily. As more organizations adopt hybrid and multi-cloud environments, the cross-platform nature of modern .NET will drive greater demand.

Language & Framework Advancements

Microsoft has continued advancing the C# programming language as well as the core .NET framework. New features in C# like nullable reference types, async streams, and top-level statements make the language even more powerful and enjoyable to use.

The .NET framework itself has also gained capabilities like Hot Reload for faster development workflows, cloud-native support through ASP.NET Core, and better integration with Kubernetes, Docker, and containers in general. These ongoing improvements help ensure .NET remains highly productive and relevant for building modern applications.

Enterprise Application Demand

While startups and smaller companies continue fueling demand, bigger enterprises rely on .NET heavily as well. According to a 2017 survey, over 80% of Fortune 500 companies use .NET for at least some applications. Many core business systems at large banks, retailers, manufacturers, and other organizations were built on .NET decades ago and require ongoing support and enhancements.

As digital transformation initiatives accelerate across all industries, these organizations will drive extensive demand for .NET skills to modernize, migrate, and expand their mission-critical applications. Budgets for application development, maintenance, and DevOps are growing, and .NET has an established place within many major companies.

Rising Demand for Full-Stack Skills

Full-stack development combining both front-end and back-end skills is increasingly desirable for building complete applications. Companies want developers who can work with the entire tech stack rather than specialists in just one area.

With the introduction of Blazor in .NET 5, developers can now create rich web UIs using C#/Razor components that run in the browser with WebAssembly instead of traditional JavaScript frameworks. Blazor has the potential to reshape full-stack development by unifying client and server using a single language.

As the Blazor ecosystem matures, demand for .NET developers with complementary skills like C#, ASP.NET Core, and Blazor will grow substantially. Those with full-stack .NET backgrounds will be highly sought after.

Employment & Salary Outlook

The combination of increased adoption, ongoing enhancements, and rising demand across industries means the job prospects and earning potential for .NET developers remains strong.

According to data from Dice and other job sites, the number of .NET-related postings on Indeed increased by over 150% between 2017-2021. Average base salaries for intermediate and senior .NET positions typically range from $80,000 to $130,000 per year in the US. Many locations also have lower costs of living than tech hubs.

Long-term forecasts also indicate robust growth ahead. The Bureau of Labor Statistics projects a 9% increase in jobs for software developers through 2030, much faster than average. For experienced .NET professionals, job security and opportunities for career advancement or job-hopping should remain plentiful in 2024.

In summary,

with the platform's cross-platform flexibility, advancing language and features, entrenchment in major enterprises, rise of full-stack opportunities, and abundant job prospects, the overall demand profile of .NET development looks exceedingly bright as we head into 2024 and beyond. Strong professionals in the .NET ecosystem can feel confident about the continuing need and usage of their skills.

Tips to Create Your First ASP.NET Core Application

Janki Mehta — Wed, 27 Dec 2023 11:40:41 +0000

ASP.NET Core is one of the most popular open-source web frameworks for building modern web applications and services on the .NET platform. Its modular and lightweight design, cross-platform support, high performance, and rich ecosystem make it a great choice for building web APIs, websites, mobile backends, and more.

In this beginner-friendly tutorial, we'll build a simple "Hello World" ASP.NET Core web application from scratch. We'll walk through:

Setting up the development environment with the .NET Core SDK
Creating a new ASP.NET Core project
Running the app locally
Adding a basic web API endpoint
Testing the output

By the end, you'll have a good foundational understanding of how ASP.NET Core works and be ready to build more complex real-world applications. The goal is to get you up and running with core concepts so you can start leveraging the power and capabilities of ASP.NET Core for your own projects.

Let's get started!

Prerequisites

Before we start, make sure you have the following installed:

.NET Core SDK 3.1 or later
A text editor or IDE like Visual Studio, Visual Studio Code etc.

Create the Application

Let's start by creating a new ASP.NET Core web application.

Open a command prompt or terminal and navigate to the directory where you want to create the app.
Type the following command:

dotnet new web -o MyFirstApp

It will create a new ASP.NET Core web project in a folder called MyFirstApp.

Navigate into this new folder:

cd MyFirstApp

The project contains a Program.cs file with the entry point code and a Startup.cs file for configuring services and the request pipeline.

Run the Application

We can now run the web app locally to see the default page.

From the command prompt in the application folder, run:

dotnet run

Open a web browser and go to https://localhost:5001. You should see the default ASP.NET Core web page.

Add Some Code

Let's add a simple API endpoint to return "Hello World".

Open the Startup.cs file.
Add the following code inside the Configure method:

app.Run(async context => 
{
   await context.Response.WriteAsync("Hello World!"); 
});

Run dotnet run again and refresh the browser. You should now see "Hello World!"

And that's it! We now have a simple ASP.NET Core web application up and running.

Next Steps

This was just a basic example to get started. From here, you can start adding controllers, views, models etc., to build a real web application.

The official ASP.NET Core docs are a great next resource to learn more about ASP.NET Core and its features.

We walked through setting up the development environment, creating a new project, running the application locally, adding a basic API endpoint, and testing the output. This should give ASP.NET Core developers a good overview of the basic structure and workflow of ASP.NET Core applications. Of course, this was just a simple example - ASP.NET Core is capable of powering robust, scalable enterprise web applications and services. The official documentation contains many more in-depth guides on leveraging the full capabilities of ASP.NET Core.

I hope this tutorial served as an easy way for ASP.NET Core developers to get started building web applications on the .NET platform. Let me know if you have any other questions!

Collecting Metrics in ASP.NET Core Applications

Janki Mehta — Wed, 20 Dec 2023 13:30:52 +0000

Monitoring and metrics are crucial for any production application. It provides visibility into how your application is performing, helps with debugging issues, and enables data-driven decisions for improving performance and scalability. This post will explore common ways to collect and expose metrics from ASP.NET Core applications.

What are Metrics?

Metrics represent quantifiable measurements about an application or system at a given time or over time. Common metrics include:

Request Count: Number of requests received by the application
Request Duration: How long do requests take on average to respond
Memory Usage: Amount of memory the application is consuming
CPU Usage: Percentage of CPU the application is using
Exception Count: Number of exceptions thrown by the application
Response Status Codes: Breakdown of response status codes (200, 404, 500 etc.)

A metric by itself doesn't tell much but provides insightful trends over time. Metrics are key to monitoring, alerting, performance baselining, and application capacity planning.

Built-in ASP.NET Core Metrics

ASP.NET Core comes with built-in support for collecting some basic out-of-the-box metrics. These metrics are exposed through the HttpMetrics Middleware registered by default in CreateWebHostBuilder().

Some of the key built-in metrics are:

Request Count
Response Count (broken down by status code)
Total Request Duration
Request Duration (broken down by status code) The middleware writes these metrics to the HTTP response headers on every request. It makes them easily accessible without additional infrastructure.

For example, you could view the metrics using Postman or curl to inspect the X-aspnet-Version X-AspNet-Variables-RequestCount response headers.

X-AspNet-Version: 5.0.0-rc.2.20475.5
X-AspNet-Variables-RequestCount: 6
X-AspNet-Variables-RequestDuration-Sum: 3.424999999402344
...

While convenient, exposing metrics only via headers has limitations. Headers do not support deeper historical aggregation or flexible export options required for robust monitoring. For that, additional libraries are needed.

Metric Libraries

Several open-source libraries integrate nicely with ASP.NET Core to provide more advanced metric collection capabilities:

Prometheus

Prometheus is one of the most popular open-source monitoring systems. At configurable intervals, it supports scraping metrics via HTTP from targets like ASP.NET Core apps.
The Prometheus.AspNetCore.Metrics package allows exporting the built-in ASP.NET Core metrics in the Prometheus exposition format. It also adds additional .NET/ASP.NET-specific metrics like GC stats, Requests Inflight, memory usage, etc.
The metrics endpoint is added at /metrics Prometheus can scrape to collect data. This data can then be visualized, alerted on, etc, using the Prometheus ecosystem of tools like Grafana.

StatsD

StatsD is a protocol and server for aggregating and summarizing metrics. It supports sending metrics over UDP.
The MicroSteam.StatsD library provides StatsD client functionality and integration for ASP.NET Core. It allows easy incrementing counters, timing metrics, etc, from the application code and pipeline.
These metrics can then be sent to a StatsD server and visualized using tools like Grafana. StatsD also supports integration with other backends like InfluxDB, Prometheus, etc.

Application Insights

Application Insights is a comprehensive Application Performance Management (APM) service by Microsoft for web apps hosted in any environment, including on-premises.
The Microsoft.ApplicationInsights.AspNetCore package collects the built-in ASP.NET metrics and additional diagnostics and availability data and sends it to the Application Insights resource.
It provides out-of-the-box dashboards and search and powerful analytics capabilities on the portal. Application Insights is ideal for applications hosted on Azure.

App Metrics

App Metrics is a cross-platform .NET library for instrumenting applications and collecting metrics. It supports exporting metrics to various backends like Prometheus, InfluxDB, ElasticSearch, etc.
The App.Metrics.AspNetCore package provides middleware to collect ASP.NET Core metrics like request counters, durations, etc and integrates with the App Metrics instrumentation API.
It is lightweight, has minimal overhead, and provides a consistent metrics API across platforms and languages. App Metrics works well even for non-Azure-hosted applications.

Choosing the Right Library

Here are some factors to consider when choosing a metrics library:

Deployment Platform: Application Insights is ideal for apps hosted on Azure. Prometheus for Kubernetes/Docker environments. StatsD for generic backend agnostic collection.
Visualization Needs: If requiring out-of-the-box dashboards, Application Insights excels. Prometheus/Grafana or custom solutions on top of StatsD/App Metrics works.
Backend Preferences: Prometheus for Prometheus and Elasticsearch. StatsD for Sumo Logic, Datadog etc. Application Insights for its backend.
Portability: App Metrics work across platforms. Prometheus is only for HTTP targets. Application Insights tied to MS ecosystem.
Overhead: Application Insights and Prometheus have more startup overhead than App Metrics or StatsD.
Feature Set: Application Insights is most fully featured for APM. Prometheus for observability. StatsD/App Metrics for lightweight collection. Hence, Application Insights is easy to use for Azure-hosted apps. Prometheus for complex on-prem/containerized setups. StatsD/App Metrics for low overhead collection with flexible exporters.

Instrumenting Code

Collecting application-level metrics requires instrumenting the code in strategic places. Here are some examples:

Track Request Timing
Use the IActionFilter to track request timing:

public class RequestTimingFilter : IActionFilter 
{
  public void OnActionExecuting(ActionExecutingContext context) 
  {
    context.HttpContext.Items["Timer"] = Stopwatch.StartNew();
  }
  public void OnActionExecuted(ActionExecutedContext context)
  {
    var timer = context.HttpContext.Items["Timer"] as Stopwatch;
    timer.Stop();
    // Record request duration
    var appMetrics = context.HttpContext.RequestServices.GetRequiredService<IAppMetrics>(); 
    appMetrics.Measure.RequestDuration.Measure(timer.Elapsed); 
  }
}

Track Dependency Calls

Track timing of external dependency calls:

public async Task<IActionResult> Index() 
{
  var timer = Stopwatch.StartNew();
  // Call dependency   
  var result = await _client.GetUsers();  
  timer.Stop();
  // Record duration
  var appMetrics = HttpContext.RequestServices.GetRequiredService<IAppMetrics>();
  appMetrics.Measure.Dependency("Database").Measure(timer.Elapsed);
  return View(result);
}

Track Exceptions

Count exceptions occurring in specific code blocks:

try
{
  // Method that could throw
}
catch (Exception ex)
{
  var appInsights = HttpContext.RequestServices.GetRequiredService<Microsoft.ApplicationInsights.TelemetryClient>();
  appInsights.TrackException(ex);  
}

Instrumenting at strategic places like this provides actionable insights without many code changes.

Exposing Metrics Endpoint

Most metric libraries provide a way to expose metrics through an endpoint that can be scraped. For example:

Prometheus

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
  app.UseMetricServer();
}

StatsD

app.UseMetricsEndpoint("/stats",
  metrics => metrics.Statsd())

Exposes metrics at /stats

App Metrics

app.UseMetricApi();

Exposes metrics via Prometheus, InfluxDB endpoints

Scraping this endpoint periodically provides a consistent way to collect metrics in production. Services like Prometheus are ideal for automated scraping.

Alerting on Metrics

While metrics provide visibility, it's also important to configure alerts to be notified of issues. Metric libraries typically integrate with alerting systems:

Prometheus Alertmanager

Prometheus has an integrated Alertmanager for grouping, routing, and sending alerts. Rules can be configured using the Prometheus Query Language to fire alerts based on metric thresholds.
For example, to alert if requests are taking more than 1 second on average:

alert: SlowRequests
expr: avg(aspnet_request_duration_seconds_bucket{le="1"}) < 0.9
for: 5m

Alerts can be sent via email, PagerDuty, Slack, etc. This provides automated notifications for performance issues.

Application Insights Alerts

In Application Insights, metric alerts can be configured on dashboards, workbooks, or directly in the portal.
Custom metric queries allow setting alerts on application-specific metrics, too. Notifications go to email, SMS, ARM templates, and more.

App Metrics Alerts

App Metrics exposes Prometheus-compatible metrics so that the Alertmanager can be used. Its plugin model also supports sending alerts to external systems like Slack.

Logging and Tracing

While metrics provide a high-level overview of an application, diagnosing issues requires correlating them with logs and traces:

ASP.NET Core Logging
The logging APIs allow capturing logs across the application. Libraries like Serilog and NLog provide rich log formatting and routing.

Application Insights Tracing

Application Insights application tracing correlates logs, exceptions, and external dependencies with requests' client-side performance.

Distributed Tracing with Prometheus

Prometheus can be combined with a distributed tracing system like Jaeger to trace requests across services. Libraries like OpenTelemetry make it easy to generate and propagate distributed traces.
Bringing logs, traces, and metrics together provides deep insights needed to debug performance bottlenecks and failures across complex applications and microservices.

Performance Benchmarking

To establish performance benchmarks, tools like:

Gatling: Load test ASP.NET Core APIs and analyze results.
K6: Open source load testing tool with JavaScript scripting.
Neoload: Commercial load testing tool.
Vegeta: CLI tool for hammering URLs.

Running performance tests against baseline configurations helps determine scalability bottlenecks and capacity planning. Metrics from tests can be exported to the same backend as production for apples-to-apples comparison.

Summary
Setting up a comprehensive monitoring and metrics platform is crucial for the production ASP.NET Core apps. The built-in middleware provides a good starting point. Libraries like Prometheus, Application Insights, StatsD, and App Metrics integrate to collect deeper metrics seamlessly. Instrumentation at the right places provides actionable insights. Alerts detect issues and bring log traces together, providing full diagnostics. Performance tests help establish benchmarks for scaling. With the right approach, actionable insights can be gained without much operational overhead.

Node.js vs NestJS – Understanding their Technical Difference

Janki Mehta — Mon, 11 Dec 2023 13:23:15 +0000

Node.js and NestJS are both popular JavaScript platforms for building efficient, scalable server-side applications. Node.js is a runtime that allows developers to use JavaScript on the server, while NestJS is a framework that builds on top of Node.js, providing more structure and scalability out-of-the-box.

Both have their pros and cons and are better suited for certain types of applications. At a high level, Node.js offers more flexibility and works well for simple APIs and microservices, while NestJS shines when building complex, enterprise-grade applications thanks to its robust feature set.

This article will provide an overview of both platforms, compare their architectures and performance, discuss factors to consider when choosing one or the other, and make some recommendations on when NestJS is the better option over plain Node.js or vice versa.

Node.js Overview

Node.js exploded in popularity upon its release in 2009, thanks to its ability to execute JavaScript code outside of the browser, its efficient use of asynchronous/non-blocking I/O, and its support for real-time applications.

Instead of waiting for requests and responses to complete before moving to another task, Node.js uses an event loop that allows it to handle high volumes of concurrent requests without incurring the overhead of managing threads. This makes Node.js well-suited for data-intensive real-time applications like chat rooms and streaming platforms.

Benefits of Node.js

Large ecosystem of open-source libraries and tools
Great for prototyping and iterating quickly
Lean and fast compared to other server-side frameworks
JavaScript skills transfer nicely from front-end

Downsides of Node.js

Limited structure and architecture can be chaotic
Heavy use of callbacks can lead to callback hell
Not great for complex or enterprise-grade applications
Must assemble most features yourself

Hence, Node.js is a great choice for lightweight web applications, simple APIs and microservices, anything requiring real-time data, and MVPs or prototypes where flexibility and speed of iteration is key.

NestJS Overview

Released in 2016, NestJS provides an out-of-the-box application architecture for building scalable Node.js servers using JavaScript/TypeScript. It officially bills itself as "a progressive Node.js framework for building enterprise-grade efficient, reliable, and scalable server-side applications."

Capabilities of NestJS

Built-in support for a modular organization using controllers, providers, modules, and more
Sophisticated dependency injection system
A CLI tool for the generation of boilerplate code
Easy to implement middleware and guards thanks to built-in decorators
Exception filters for centralized error handling
Framework for unit and e2e testing

By providing structure, NestJS makes larger applications much easier to maintain and expand. The learning curve is a bit steeper than Node, but they’ve done a great job making documentation and training resources readily available.

Downsides compared to Node.js are mainly increased complexity and tighter coupling to the NestJS platform. The framework handles so much automatically that migrating away later requires significant refactoring.

Use cases where NestJS shines over bare Node.js

Highly scalable applications needing easy maintenance
Anything with intricate business logic or complex flows
Teams with less experienced Node developers
When unit testing and sound architecture are key
Processing lots of data across distributed systems
CRUD APIs requiring validation, authorization, logging automatically

Hence, while Node.js gives you a canvas and brush to create your own masterpiece, NestJS provides a rich set of paint-by-numbers features so engineering teams can build robust applications faster.

Differences between NodeJS and NestJS

Comparing Architectures

There are quite a few differences between Node.js and NestJS under the hood, but we’ll focus on some key ones around file structure and request handling flow.

File Structure

A typical Node.js application might just throw all server logic into a single index.js file, or separate concerns across a simple controllers/, services/, models/ type folder structure. NestJS enforces further modularization using:

Controllers: Handle incoming requests and return responses
Providers: Services that contain core business logic, interacting with databases, making API calls, etc.
Modules: Self-contained units of business capabilities that group related controllers/providers
Middleware: Functions executed during the request handling pipeline
Guards: Functions that control access to specific endpoints

Request Handling Flow

When a request comes into a Node.js app, you manually take that request and route it across any number of modules, controllers, and services you’ve wired up. Any middleware needs to be explicitly inserted as well.

NestJS sets things up differently using dependency injection and a built-in IoC container. A request first hits any global middleware then flows through a pipeline roughly like:

Request -> Guard -> Interceptor -> 
    -> Controller -> Service -> Repository

It provides standardization and consistency across implementations.

Performance

As far as runtime performance and benchmarks, NestJS introduces minimal overhead over Node, usually less than 1%. For example, a common benchmark serving JSON shows Node.js at ~31k requests/second and NestJS at ~30k.

So, in terms of pure speed, the two are very comparable. Where Nest really accelerates development velocity is through its robust feature set and architectural conventions.

Considerations in Deciding Which one to choose. NodeJS or NestJS
When embarking on a new project, how do you decide whether to use NestJS versus plain Node.js? Here are some factors to weigh.

Team & Project

Team experience level with Node/Nest and typescript
App complexity and size
Desired development velocity
Availability of quality Node.js dev resources

Business Factors

Target users and expected traffic
Pace of enhancement/feature requests
Application availability/stability needs
Compliance requirements

Technical Factors

Integration needs with external services/databases
Real-time requirements like chat or streaming
Need for scalability/maintainability
Testing needs and CI/CD processes

If your team is familiar with Node and TypeScript, starting with NestJS as the baseline for almost any material project is likely to pay off exponentially in long-term velocity and stability.

Summary and Recommendations

To summarize the key differences:

Node.js offers ultimate flexibility while NestJS provides structure and conventions
Node good for simple real-time services and micro front-ends.
Nest enables robust complex applications, with integrated best practices
Nest has steeper initial learning curve Here are some quick rules of thumb on when to default to each:

Node.js

Simple CRUD APIs and microservices
Prototyping ideas where speed matters most
Front-end Node microservices
Public-facing real-time features
NestJS
Nearly everything else!
Internal enterprise applications
Heavy business logic
Cross functional/database integrations
Legacy codebases benefitting modernization
Prioritizing maintainability

The overhead NestJS introduces gets paid back over the long haul via accelerated development velocity, clean architecture, and easy maintainability. Unless building a public API to support millions of users per day, teams are usually better served starting with NestJS from the get-go.

Style a DataTable in React Native Paper

Janki Mehta — Wed, 06 Dec 2023 07:03:33 +0000

The DataTable component in React Native Paper provides a clean and customizable way to display tabular data on mobile. However, out of the box, it comes with default styling that may not always fit with the design and styling of your application. Fortunately, the DataTable is fully customizable through React Native styling, which allows you to precisely control elements like colors, spacing, borders, and more to match your branding and user interface guidelines.

Styling the DataTable correctly is important to provide a consistent and polished experience for users when viewing and interacting with lists of data. This article will demonstrate some common techniques for styling the key elements of the DataTable, such as the header, rows, and individual cell content, to achieve a custom look and feel.

Here's the Tips to Style a DataTable in React Native Paper

import React Native Paper and the DataTable component:

import { DataTable } from 'react-native-paper';

Define some sample data as an array:

const data = [
  {
    id: 'bd7acbea-c1b1-46c2-aed5-3ad53abb28ba',
    firstName: 'First Name 1',
    lastName: 'Last Name 1'
  },
  {
    id: '3ac68afc-c605-48d3-a4f8-fbd91aa97f63',
    firstName: 'First Name 2',
    lastName: 'Last Name 2'
  },
  // etc
];

Render the DataTable passing in the data:

<DataTable>
  <DataTable.Header>
    <DataTable.Title>Id</DataTable.Title>
    <DataTable.Title>First Name</DataTable.Title> 
    <DataTable.Title>Last Name</DataTable.Title>
  </DataTable.Header>

  <DataTable.Row>
    // map over data
  </DataTable.Row>
</DataTable>

To style it, wrap it in a StyleSheet:

<StyleSheet>
  <DataTable 
    style={{
      borderColor: 'blue' 
    }}
  >
    //...
  </DataTable>
</StyleSheet>

You can then style individual components like Header, Title, Row etc:

<DataTable.Title 
  style={{
    color: 'green'
  }}
>
  First Name
</DataTable.Title>

Some other useful styles include controlling padding, borders, text colors, sizes etc.

The DataTable component provides a solid foundation for displaying tabular data on mobile while also giving developers full control over styling through React Native. With some basic use of StyleSheet definitions and component-specific styles, you can customize elements like colors, sizing, spacing, and more to match any design. Taking the time to style the DataTable carefully ensures a polished user experience when viewing lists of information.
Whether you need to adjust colors or achieve a completely bespoke design simply, the styling capabilities allow you to integrate tabular content into your unique UI perfectly. For professional React JS Development teams and independent developers alike, leveraging these styling techniques provides an effective way to build out feature-rich, customizable data browsing experiences with React Native Paper.

Create SOAP Services Using ASP.NET Core

Janki Mehta — Fri, 01 Dec 2023 12:55:08 +0000

SOAP (Simple Object Access Protocol) is a messaging protocol that allows programs built with different languages and on different platforms to communicate using XML. SOAP services provide a way to expose backend functionality over the web using the SOAP messaging framework.

In this blog post, we will see how to create and consume SOAP web services in ASP.NET Core. We will learn how to:

Enable SOAP services support in ASP.NET Core

Create a SOAP web service
Add SOAP endpoints
Secure SOAP endpoints
Host and test SOAP services
Consume SOAP services in client applications

Enabling SOAP Services in ASP.NET Core

Unlike ASP.NET 4.x that has built-in support for SOAP-based web services through ASMX, ASP.NET Core does not include SOAP services capability out of the box.

We need to take help of a third-party library called System.ServiceModel.Primitives to build SOAP-based services in ASP.NET Core.

To add SOAP services support, first install the NuGet package:

Install-Package System.ServiceModel.Primitives

This package contains the necessary types and interfaces to expose and consume SOAP services. The next sections show how to build on top of this to create SOAP endpoints.

Creating a SOAP Web Service
Let's create a simple SOAP web service with one operation to get customer details by ID.

First, create an interface representing the service contract:

public interface ICustomerService
{
    Customer GetCustomer(int id); 
}

public class Customer 
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Next, implement this interface:

public class CustomerService : ICustomerService
{
    public Customer GetCustomer(int id)
    {
        // Logic to fetch data from database and return Customer
    }
}

This simple service is now ready to be exposed over SOAP.

Exposing SOAP Endpoints

ASP.NET Core does not include SOAP endpoint support out of the box. So we need to configure that ourselves.

Install the NuGet package - Microsoft.AspNetCore.WebApi.WebHost

This will allow hosting web APIs on top of HTTP servers like IIS or IIS Express.

In Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    services.AddWebApi();

    services.AddScoped<ICustomerService, CustomerService>(); 

    services.AddSoapCore();
}

public void Configure(IApplicationBuilder app)  
{
    app.UseSoapEndpoint<ICustomerService>("/CustomerService.asmx", new BasicHttpBinding(), SoapSerializer.DataContractSerializer);
}

The AddSoapCore method comes from SoapCore library that does the heavy-lifting of mapping SOAP messages over HTTP.

And UseSoapEndpoint maps the specified interface to the SOAP endpoint, with binding and serialization set up.

We can now access the SOAP service using HTTP requests like any REST API. The next section shows how to test this.

Testing the SOAP API
Let's test our SOAP API using SoapUI or Postman.

A sample request XML looks like:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tem="http://tempuri.org/">
   <soapenv:Header/>
   <soapenv:Body>
      <tem:GetCustomer>
         <tem:id>1</tem:id>
      </tem:GetCustomer>
   </soapenv:Body>
</soapenv:Envelope>

And response like:

<s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/">
  <s:Body>
    <GetCustomerResponse xmlns="http://tempuri.org/">
      <Customer>
        <Id>1</Id>
        <Name>John</Name>
      </Customer>
    </GetCustomerResponse>
  </s:Body>
</s:Envelope>

We can send requests and view responses either in SoapUI or using Postman. This confirms our service is working as expected.

Securing SOAP Services

Since SOAP services expose backend application logic, it is important to secure access to them. Some ways to secure SOAP services include:

1. Transport-Level Security using HTTPS

Require SSL and allow requests only using HTTPS protocol.

2. Message-Level Security

Use WS-Security to encrypt SOAP requests and responses.

3. Authentication and Authorization

Validate sender identity using security tokens or API keys before processing requests.

This ensures that only authorized clients can access the SOAP API.

Here is an example to secure the service using API key authentication:

// Validate API Key existence
if(!Request.Headers.Contains("X-API-Key")) 
    throw new Exception("Unauthorized");

// Check if API Key is valid
if(!IsAPIKeyValid(Request.Headers["X-API-Key"])) 
    throw new Exception("Forbidden");

// Allow request

We can implement other authentication mechanisms like OAuth as well.

Hosting ASP.NET Core SOAP Services

To host the SOAP web service, configure the ASP.NET Core app to use the IIS/IIS Express hosting model:

public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
        .UseStartup<Startup>()
        .UseIIS();

Alternatively, we can self-host the service using Kestrel.

For production use, hosting behind IIS with transport security is recommended.

Consuming SOAP Web Services
To consume ASP.NET Core SOAP web services from a .NET client:

Add service reference to client project
Generate proxy client code
Create client instance and invoke service operations For example:

// 1. Add service reference 

// 2. Generate proxy
var client = new CustomerServiceClient();  

// 3. Call operation
var customer = client.GetCustomer(1);

The service reference handles all serialization/deserialization and communication with the SOAP endpoint.

For Java or other language clients, we can consume the ASP.NET Core SOAP service by generating client code using the wsdl file.

Last Words

In this post, we learned how to build and expose SOAP web services in ASP.NET Core using the SoapCore library. Some of the key things we covered:

Adding NuGet packages for SOAP support
Creating service interfaces and implementation
Configuring SOAP endpoint routing
Testing SOAP API using SoapUI/Postman
Securing services with authentication and HTTPS
Hosting SOAP services in IIS
Consuming from .NET clients

SOAP services allow exposing backend application logic in a standardized way. Integrating them securely into modern web apps allows reusing existing systems.

Hope this gives you a good overview of building SOAP-based services in ASP.NET Core web applications!

Source: How to Create SOAP Services Using ASP.NET Core?

React Native vs Swift: Which is Best for Your Mobile App Development?

Janki Mehta — Wed, 29 Nov 2023 11:23:06 +0000

As a mobile app developer, you have many options for which platform and programming language to choose when building a new app. Two popular choices are React Native and Swift. Both allow you to create fully functional mobile apps for iOS and Android. But each has its own strengths and weaknesses. In this blog post, we will compare React Native vs Swift across several key factors to help you determine which is the best technology for your needs.

Overview

React Native is a JavaScript library open-sourced by Facebook in 2015 that allows you to build mobile apps using React and JavaScript. With React Native, developers can build once and deploy to both iOS and Android with shared code without writing platform-specific code.

Swift is a general-purpose, multi-paradigm, compiled programming language developed by Apple and first released in 2014. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and works seamlessly with iOS, macOS, watchOS, and tvOS. With Swift, you can build fully native iOS and macOS apps.

Comparison Table: React Native vs Swift

Swift vs React Native – Difference on Various Factors

Development Experience and Tools

The main development tools for React Native are React tools, VS Code, WebStorm, and other IDEs that support React/JavaScript development. Developers code in JavaScript using React components and APIs.
The primary development tool for Swift is Xcode, Apple's integrated development environment (IDE). Xcode includes tools like storyboards for building UI, the Swift compiler, and debugger. Code is written in Swift and seamlessly integrated with native iOS libraries and APIs.
The learning curve for React Native is generally steeper than Swift since it requires knowledge of JavaScript, React, and some mobile development concepts. Swift is easier for iOS developers since it's similar to Objective-C.

Performance

React Native apps are reported to have near-native performance. The React Native bridge converts JavaScript calls to native platform calls, allowing components to render at 60 FPS. However, there may be some additional overhead compared to fully native apps.
Swift delivers true native performance since code runs directly on the device like a standard iOS app. Animation and interaction will be indistinguishable from other apps on the store since everything renders using the same UIKit framework.

Cross-Platform Development

The big advantage of React Native is cross-platform capabilities. With largely shared code, you can develop once and release to both iOS and Android platforms, cutting development time versus writing fully native code.
Swift is a native language, so code only runs on Apple platforms like iOS, macOS, watchOS, or tvOS. If targeting other platforms like Android, you would need to rewrite code or use a cross-platform framework like React Native or Flutter.

Integration with Native Features

While React Native exposes many common mobile features through wrappers and APIs, it's always an extra abstraction layer away from the true native platforms. For cutting-edge features or deeper platform integration, you may hit limits.
In Swift, everything integrates seamlessly with native frameworks right out of the box. You get direct access to the full power of devices like the camera, sensors, filesystem, etc, without additional layers.

Support and Community

React Native and Swift have very large, vibrant developer communities that provide help, tutorials, and open-source libraries. Facebook is actively developing React Native, with many companies adopting it.
Apple has a huge ecosystem backing Swift as the primary language for their platforms. Resources and help will be easily available if issues arise. Swift also has a bright future as Apple continually invests in the language.

FAQs

Q1. Which is easier to learn - React Native or Swift?

Swift would generally be easier for new developers since the syntax is clearer and integrates seamlessly with Apple's platforms. React Native introduces additional concepts like JavaScript React, which requires more background learning.

Q2. Can I create both iOS and Android apps with Swift?

Swift is only for building native iOS, watchOS, macOS, and tvOS applications. To target Android, you would need a cross-platform framework like React Native or Flutter.

Q3. How is React Native animation and interaction compared to native?

Animation and interaction with React Native are close to native but not the same since it renders using the native platform's APIs rather than directly using platform UI frameworks. Advanced animations may require additional work.

Q4. Is React Native suitable for complex apps with intensive graphics?

React Native can handle complex apps, including 3D games and AR/VR experiences. But for the most intensive graphical needs, a fully native solution may have an advantage in terms of raw performance.

Q5. How do updates work in React Native vs native apps?

With React Native, you can ship code and API updates through JavaScript bundles, avoiding the app store approval process. Native app updates must go through app stores for installation on users' devices.

Q6. What are some limitations of React Native?

Potential limitations include performance overhead, limited ability for truly native look/feel, bugs from SDK mismatches, third-party library compatibility, and debugging challenges.

Q7. How do I connect React Native to backend servers?

Common ways include utilizing fetch API for HTTP requests, WebSocket connections for real-time features, or a library like React Native Networking for a higher-level abstraction.

Q8. Do I need separate iOS and Android codebases in React Native?

No, with React Native, you develop using a single JavaScript codebase that can be compiled for both iOS and Android. Only a small amount of native platform-specific code is needed for each platform.

Q9. Can I use existing Swift/Objective-C code in React Native?

Yes, React Native allows the inclusion of existing Objective-C/Swift code and libraries within a project through native modules that encapsulate platform-specific functionality in a reusable way.

Q10. Which is better for large, complex enterprise apps - React Native or Swift?

Both can work well for large, complex apps. React Native enables easier cross-platform development, while Swift delivers best-in-class native performance. For an established iOS-first enterprise, Swift may integrate more seamlessly into existing codebases and processes.

Final Thought on React Native vs Swift

Both React Native and Swift are outstanding options for building high-quality mobile apps. React Native allows development for multiple platforms like iOS and Android using shared JavaScript code. At the same time, Swift is the optimal choice for fully utilizing the power of iOS, macOS, and other Apple platforms.
Ultimately, the right choice comes down to your specific needs - platforms supported, performance requirements, development experience preferences, and existing codebase or tools. Consider prototyping with both to see which suits your use case better before committing long-term. With the large communities behind each, you can create amazing mobile experiences with either technology.

How to Create PDF Documents in ASP.NET Core

Janki Mehta — Fri, 24 Nov 2023 05:50:34 +0000

PDF generation is a common requirement for many web applications. ASP.NET Core provides several options for generating PDF documents directly from .NET code. In this article, we'll explore some of the main approaches for creating PDFs in ASP.NET Core apps.

We'll cover:

Using built-in PDF generation support
Third-party libraries like iTextSharp and PDFSharp
Generating PDFs from HTML/CSS using libraries like PDFKit and Puppeteer Sharp
Rendering to PDF on the server vs the client
Sample code for a basic PDF generation scenario

By the end, you should have a good understanding of the different techniques available and how to get started generating PDFs from your ASP.NET Core applications.

Built-in PDF Support

The .NET Framework and .NET Core provide some basic built-in functionality for generating PDF documents programmatically without a third-party dependency.

The System.Drawing namespace includes classes like PdfDocument and XGraphics that allow creating PDF files pixel-by-pixel. You can draw text, images, vectors, and more onto a PdfPage and save the result as a PDF file.

An example:

// Create a new PdfDocument object
var pdfDoc = new PdfDocument(); 

// Add a page
pdfDoc.AddPage();

// Get an XGraphics object for drawing
var gfx = XGraphics.FromPdfPage(pdfDoc.Pages[0]);

// Draw text  
gfx.DrawString("Hello World!", font, XBrushes.Black, 0, 0);

// Save the document and dispose it
pdfDoc.Save("HelloWorld.pdf");
pdfDoc.Dispose();

This provides a basic building block but has limitations. Text/layout is rendered pixel-by-pixel so it may not scale or print well. There is also no support for things like vector graphics, tables, hyperlinks etc.

For richer PDF generation capabilities, third-party libraries are recommended.

Third-Party Libraries

There are a number of high-quality third-party .NET libraries for generating sophisticated PDF documents from code:

iTextSharp

iTextSharp is one of the most full-featured and mature open source .NET PDF libraries available. It allows building PDF documents from scratch using elements like paragraphs, tables, images etc. Layout is handled separately from rendering so documents scale well.

An example:

// Create a document and open it  
Document pdfDoc = new Document(PageSize.A4, 25, 25, 25, 25);
PdfWriter.GetInstance(pdfDoc, ms);
pdfDoc.Open(); 

// Add content
Paragraph p = new Paragraph("Hello World!");
pdfDoc.Add(p);

// Close the document
pdfDoc.Close();

PDFSharp

PDFSharp is another popular open source .NET library. It uses a page-oriented model and the drawing API is similar to GDI+. This makes it easy to render to PDF from existing GDI/GDI+ code.

An example:

// Create a new PDF document
PdfDocument pdfDoc = new PdfDocument();

// Add a page
PdfPage page = pdfDoc.AddPage(); 

// Get drawing object and render
XGraphics gfx = XGraphics.FromPdfPage(page);
gfx.DrawString("Hello World!", font, XBrushes.Black, 0, 0);

// Save the document
pdfDoc.Save("HelloWorld.pdf");

wkhtmltopdf

wkhtmltopdf is a command line tool that renders HTML/CSS to PDF using the Webkit rendering engine. It can be used from .NET code by launching the process. This allows generating PDFs from dynamic HTML/CSS content.

// Render HTML to a stream
var proc = new Process()
{
   StartInfo = new ProcessStartInfo
   {
      FileName = "wkhtmltopdf.exe", 
      Arguments = $"-q - -",
      RedirectStandardInput = true, 
      RedirectStandardOutput = true
   }
};

proc.Start();
proc.StandardInput.Write(html);
proc.StandardInput.Close();
proc.WaitForExit();

// Output stream contains PDF
pdf = proc.StandardOutput.BaseStream;

These are some of the most popular .NET PDF libraries. Each has its strengths - choose based on your specific requirements.

Generating from HTML/CSS

Another common approach is to generate PDF from HTML/CSS content since it's easy to work with. There are a few options for doing this in .NET:

PDFKit

PDFKit is a .NET library that uses the HTML rendering engine WebKit to convert HTML + CSS to PDF documents.

// Create a PDFKit document
var pdfDoc = new PdfDocument(); 

// Add a page and render HTML
var page = pdfDoc.AddPage();
page.Render(markup); 

// Save PDF
pdfDoc.Save("HelloWorld.pdf");

Puppeteer Sharp

Puppeteer Sharp is a .NET port of the Puppeteer Node.js library for controlling headless Chrome. It can render HTML to PDF using the Chromium rendering engine.

var browser = await Puppeteer.LaunchAsync(options);
var page = await browser.NewPageAsync();

await page.GoToAsync(url);
await page.PdfAsync(output);

await browser.CloseAsync();

HTML to PDF Converter

This library uses the HTML Rendering engine in .NET to convert HTML markup to PDF.

var html = @"<h1>Hello World!</h1>";

var pdf = HtmlToPdfConverter.ConvertHtmlToPdf(html);

File.WriteAllBytes("HelloWorld.pdf", pdf);

Hence, these options allow rendering dynamic HTML/CSS content to high-fidelity PDF documents from .NET.

Server vs Client Rendering

There are two main approaches for generating PDFs - on the server or client-side:

Server-Side

Generate PDF directly from server code using a library
Respond with generated PDF file
Server handles all processing

Pros:

Faster response for users
No client-side dependencies
Easier to implement

Cons:

More load on server
No interactivity

Client-Side

Return HTML/data needed to render PDF
Use client-side library like jsPDF to generate PDF in browser
User downloads/gets link to generated file
Pros:

Reduces server load
Allows for richer interactivity

Cons:

Slower initial response
Requires client-side code/libraries So for simple static PDFs, server-side is better. For interactive/dynamic generation, consider a client-side approach.

Example Project
To put this into practice, here is a simple ASP.NET Core MVC sample project that generates a PDF on the server:

// Controller action
public IActionResult GeneratePdf() 
{
   // Create document object
   Document pdfDoc = new Document(PageSize.A4, 25, 25, 25, 25);

   // Write content
   WriteParagraph(pdfDoc, "Hello World!");

   // Write to memory stream
   MemoryStream ms = new MemoryStream();
   PdfWriter.GetInstance(pdfDoc, ms);

   pdfDoc.Close();

   // Return generated PDF
   return File(ms.ToArray(), "application/pdf");
}

// Helper to add paragraph
private static void WriteParagraph(Document pdfDoc, string text)
{
   Paragraph p = new Paragraph(text);
   pdfDoc.Add(p);
}

This demonstrates:

Creating a PDF using iTextSharp
Adding simple content
Writing PDF to a stream
Returning PDF file result

With this approach, the server generates the PDF on request without any client-side processing required.

Final Thoughts

In this article, we covered several techniques for programmatically generating PDF documents from ASP.NET Core applications. Whether you need a simple solution or full featured generation, .NET provides many high quality options.

The key aspects discussed were:

Leveraging built-in .NET PDF support
Popular third-party libraries like iTextSharp and PDFSharp
Generating PDFs from HTML/CSS content
Rendering on server vs client
Sample code for a basic PDF generation scenario

With the right approach, ASP.NET Core makes developing PDF generation capabilities straightforward. Choose the technique that best fits your specific application requirements.

How to Assess C# Skills and Experience in Interviews

Janki Mehta — Mon, 20 Nov 2023 12:49:48 +0000

As a hiring manager looking to fill C# developer roles, you want to make sure you properly assess candidates' skills and experience with the language and related technologies. Vetting C# capabilities thoroughly during the interview process is crucial for identifying the right people to add to your team.

In this blog post, we’ll explore tips and techniques for evaluating C# developers' abilities through questions, code samples, and practical exercises. Read on to learn how to dig into candidates' knowledge across a range of areas like .NET Framework, object-oriented principles, web development, and cloud platforms. With the right interview approach, you can gain invaluable insights into applicants' real-world expertise.

Review Their Resume and Background

The interview begins long before the actual meeting itself. Closely examining a candidate's resume, cover letter, and other background materials provides early clues about their experience with C# and related technologies.

Here are key things to look for:

Previous Job Titles and Descriptions: Look for specific roles like C# Developer, .NET Developer, and Web Applications Developer. Also, note how long they spent in each relevant position. Longer tenures suggest stronger abilities.
Projects and Achievements: Scan for examples of major projects or apps they built with C#. What problems did they solve, and what specific tasks did they handle? How large were the codebases?
Open-source Contributions: Involvement with open-source C#/NET projects, like contributing to .NET Core, indicates a passion for the ecosystem. Even minor bug fixes to GitHub repositories can demonstrate real coding abilities.
Overall Years of Experience: While not always a perfect proxy, more years working professionally with C# generally equates to deeper knowledge and exposure to more aspects of the language and framework.

Any other background information, like speaking at a .NET user group meeting or taking a Udemy course on ASP.NET Core, also helps paint a picture of their overall skills.

By cataloging candidate’s backgrounds ahead of time, you’ll have a framework to dig deeper into their experiences during the interviews.

Ask About Their Education and Training
Formal education and training provide a structured way for developers to build C# skills. Be sure to discuss these topics:

Related Major/Degree: Did they study computer science, software engineering, or another related field? Relevant university degrees suggest basic coding skills and theoretical knowledge.
C# or .NET Focused Courses: Many schools offer specific classes on building applications and web services with C#. These courses dive deep into language features and framework capabilities. Ask about any noteworthy projects or apps created for class assignments.
Certifications: C# and .NET certifications demonstrate commitment to mastering the technology. Microsoft, in particular, offers various credential programs related to its development stack, like the Microsoft Certified Solutions Developer certification. There are also 3rd party certification bodies with C#-focused programs.
Online Classes: With the wealth of e-learning content available today, many developers supplement their practical experience with online classes. Platforms like Pluralsight, Udemy, and LinkedIn Learning all offer robust C# content. See if they’ve taken relevant courses covering ASP.NET, Unity, or other topics.
Bootcamps/Intensive Training: Some candidates from non-traditional backgrounds attend intensive coding boot camps focused on C# and .NET skills. These accelerated 3-12 week programs aim to equip new developers with practical abilities through hands-on training. Ask about their boot camp curriculums and post-graduation projects.
Conference/Meetup Attendance: Active membership in the C# community, through attending conferences like Microsoft Ignite or Meetup groups, demonstrates engagement. Speaking/presenting at these events takes it a step further. The combination of formal coursework, certifications, online training, and community participation all help build a well-rounded skillset.

Discuss Their Hands-On C# Coding Skills

While resumes and education provide background context, you need to directly assess candidates’ hands-on C# skills during the interview. Through coding challenges, take-home projects, and questions on language internals, you can get a sense of how they apply their knowledge.
Here are effective ways to evaluate their proficiency:

Give Coding Challenges Focused on C#/NET Concepts: Have them write LINQ queries, build objects that implement interfaces, work with asynchronous code, or demonstrate other language-specific capabilities with short coding prompts. This shows if they can quickly translate concepts into real C# code.
Provide Realistic Coding Problems Resembling On-the-job Tasks: Avoid puzzles and theory-heavy algorithm questions. Instead give prompts like building part of a web API, a simple IoT application, or code to parse/process a sample data file. The goal is to simulate actual problems developers face day-to-day.
Ask About Debugging Techniques: Every developer spends significant time fixing bugs. See how they walk through diagnosing different issues like infinite loops, race conditions between threads, unhandled exceptions, etc. This demonstrates how they approach debugging in their daily work.
Discuss Design Principles Like SOLID: Well-designed C# code properly implements key object-oriented principles and design patterns. Dive into their knowledge of topics like the single-responsibility principle, inversion of control/dependency injection, and others.
Explore Language Internals: Developers working extensively with C# should have an advanced grasp of how the language itself functions under the hood - topics like memory management, garbage collection, extension methods, etc. Pose questions that demonstrate their understanding of internal processes. The aim is to give them opportunities to show competence across a spectrum of important C# coding concepts and practical techniques. If they struggle with basic language features or stumble on realistic problems, that should raise flags about gaps in their skills.

Explore Their .NET and Related Knowledge

C# does not exist in a vacuum. Experienced C# developers should have knowledge of the key frameworks, libraries and ecosystems that play important roles in building .NET applications.

ASP.NET: For web development, understanding ASP.NET and frameworks like ASP.NET Core is crucial. See if they have experience building web forms and MVC applications. Ask about Razor Pages, dependency injection, EF Core, authentication/authorization, and other common components of the stack.
Windows Desktop Development: Windows Forms and WPF are used for building traditional desktop GUI apps. While less common today, these are still relevant skills. Have they worked on WinForms or WPF apps in past roles? What UI development tools and patterns are they familiar with?
Unit Testing: Writing unit tests is a key part of professional C# development. Quiz them on their knowledge of frameworks like MSTest, NUnit, and xUnit. See if they follow Test Driven Development (TDD) principles in their work.
Asynchronous Programming: C# developers should understand async/await patterns for building responsive applications. Ask how they implement long-running processes without blocking execution threads. What experience do they have with Task objects?
Object-Relational Mapping: Most applications need to interface with databases, and ORM tools like Entity Framework Core facilitate this. Check if they have configured EF Core contexts and built repositories/services for data access.
REST APIs: Consuming and creating REST-based web APIs is near-universal. Do they have hands-on experience with API concepts like endpoints, verbs, authentication, and OpenAPI/Swagger documentation? Have they built web APIs from scratch?
Cloud Platforms: Services like Azure, AWS, and GCP are mainstream today. See if they have exposure deploying or managing .NET applications on these platforms, using services like App Services, Functions, and VMs. The wide .NET ecosystem greatly expands what developers can build with C#. Experience applying related technologies and libraries is a must for senior roles.

Learn About Past Projects and Accomplishments

Another perspective into candidates' capabilities comes from the actual projects they have built and led using C#.

Examples of Complete Apps or Complex Features: Have they designed and built an entire application from the ground up with C#? Maybe for a past employer or as a personal project? Understanding the scope and complexity provides insights into their ability to put concepts into practice.
Project Challenges: No major project is without roadblocks. What difficult problems did they encounter? How did they react to unexpected issues arising? What did they learn in the process?
Team Dynamics: Most developers work on teams. Did they play a lead role in defining architecture and making technical decisions? Or were they mainly focused on heads-down coding? Explore project leadership skills.
Components they Developed: On large codebases spread across teams, dig into the specific components, services, and features they own building. This demonstrates their exact coding responsibilities and skills.
Source Control Processes: Ask how they use Git and GitHub/Azure DevOps to collaborate on code projects. Do they use proper branching strategies and PR workflows?
Code Reviews: How are they involved with reviewing and providing feedback on other developers' code? This builds shared code health and quality standards across teams.
Documentation: In addition to writing code, do they help create technical spec documents, API references, inline comments, wiki pages, release notes, and other artifacts commonly worked on by developers? The better the grasp they have on the end-to-end development process, the stronger indication it is of their capabilities and experience

Final Words

Evaluating C# and .NET Development skills thoroughly during interviews takes thoughtful planning and preparation. But it’s time well spent to ensure you are making informed hiring decisions. By reviewing resumes, diving into education and training, conducting coding exercises, discussing .NET ecosystem knowledge, and exploring past projects, you can assemble a complete picture of a developer's abilities.
Keep in mind that very few candidates will check every box across the spectrum of potential topics. The goal is not to find some mythical "perfect" applicant. Instead, aim to use the interview process to filter for developers who meet the key skill bar for your specific team and projects. With rigorous C# interview practices in place, you'll avoid bad hiring mismatches and assemble a strong development team.

Related Resources

Connecting Two Web Forms in ASP.NET

Janki Mehta — Fri, 10 Nov 2023 06:47:52 +0000

Connecting multiple web forms together is a common requirement in ASP.NET web applications. For example, you may want to pass data or values from one form to another after submitting the first form. There are a few different ways to accomplish this in ASP.NET.

Using Session State

One method is to use the ASP.NET session state to store values from the first form and then retrieve them on the second form. Here are the steps:

On the first web form (Form1.aspx), save any values you want to pass to the next form in the Session state. For example:

protected void Button1_Click(object sender, EventArgs e) 
{
  Session["UserName"] = TextBox1.Text;
  Session["Email"] = TextBox2.Text;
}

After handling the postback on Form1, redirect to the second web form:

Response.Redirect("Form2.aspx");

In the page load event on the second web form (Form2.aspx), retrieve the values from Session state:

protected void Page_Load(object sender, EventArgs e)
{
  if (!IsPostBack)
  {
    string userName = Session["UserName"].ToString();
    string email = Session["Email"].ToString();

    //populate form controls with session values

  }
}

It allows you to pass data between the two forms through session state.

Using Query String Parameters

Another approach is to pass data between forms using query string parameters.

On the first form, append the values you want to pass as query string parameters to the redirect URL:

Response.Redirect("Form2.aspx?name=" + TextBox1.Text + "&email=" + TextBox2.Text);

On the second form, retrieve the query string values in the page load event:

protected void Page_Load(object sender, EventArgs e)  
{

  if (!IsPostBack)
  {
    string name = Request.QueryString["name"];
    string email = Request.QueryString["email"];

    //populate controls 

  }

}

The benefit of this approach is it avoids use of server-side state. The downside is the query string can be tampered with by the user.

Posting Form Data Via Cross-Page Posting

A third approach is to use cross-page posting to submit the form values from the first page directly to the second page. Here is how this works:

Set the PostBackUrl property on the submit button on Form1 to the URL of Form2:

<asp:Button ID="Button1" runat="server" Text="Submit" PostBackUrl="Form2.aspx" />

On Form2.aspx, the posted form values from Form1 will be available in Request.Form in the page load event:

protected void Page_Load(object sender, EventArgs e)
{

  if (!IsPostBack)  
  {
    string name = Request.Form["TextBox1"];
    string email = Request.Form["TextBox2"];

    //populate controls

  }

}

It submits the form values directly from one page to the other without redirects.

How to Develop and Deploy Fast Applications With Vite JS

Janki Mehta — Tue, 07 Nov 2023 10:51:56 +0000

Vite has rapidly become one of the most popular open-source front-end build tools. Its main selling points are nearly instantaneous server start and hot module replacement (HMR). Let's dive into how we can leverage Vite to develop and deploy blazing-fast web applications.

What is Vite.js?

Vite.js is a front-end build tool that aims to provide a faster and leaner development experience. It was created by Evan You, the author of popular frameworks like Vue.js.

Vite builds on top of native ES Module imports instead of bundles like Webpack. This allows it to serve source code over a development server extremely quickly. The production build pre-bundles your code for optimal loading in the browser.

Some key features that make Vite stand out include:

Instant Server Start
Vite achieves near-instant server start by serving source code over native ESM. There is no bundling required for development, so the server starts instantly.

Hot Module Replacement
Changes made to source files during development are reflected instantly in the browser without full page reloads. This is made possible by its HMR implementation.

Why Use Vite for App Development?

There are several compelling reasons to use Vite for web app development:

Blazing Fast Build Speeds
Production builds with Vite are extremely fast. It pre-bundles your app code intelligently, resulting in smaller bundle sizes.

Rich Ecosystem and Tooling
Vite has first-class support for frameworks like React, Vue, and Svelte. There is also a robust plugin ecosystem.

Easy Migration from Create React App
For React apps, moving from Create React App to Vite is quite straightforward. This makes it easy to migrate existing apps to Vite.

Getting Started with Vite

It's simple to get up and running with Vite. We'll cover the basics of installation, project setup, and the development workflow.

Installation and Setup
To install Vite.js on your computer, we need Node.js. Then we can scaffold a new project by running:

npm init vite@latest

This will prompt us to select a framework and provide other project details.

Project Structure Overview
The generated project structure is clean and minimal. The main files and folders are:

index.html - The HTML entry point
src/ - Contains our source code
src/main.js - The JavaScript entry point
src/App.vue - The main app component (for Vue apps)

Development Workflow
To start the dev server, just run:

npm run dev

This will serve your app at localhost:5173 by default.

Now, let's go over some key aspects of development with Vite:

Starting the Dev Server
The Vite dev server starts up instantly. You can begin coding immediately and see changes reflected in the browser immediately.

Native ESM Support
Importing JavaScript modules just works out of the box. No complex configuration is needed.

Working with Assets
Importing CSS, images, fonts, etc from JavaScript also works seamlessly. Vite handles assets extremely well.

Building and Deploying Vite Apps

Let's explore how to build and deploy apps made with Vite.

Production Build
To generate a production build, run:

npm run build

This will bundle and minimize your code with sensible defaults.

Build Options
The build can be customized via the vite.config.js file. For example, we can set the base URL for the app here.

Advanced Configurations
Vite lets you fine-tune the build output in great detail via its API and plugins. This flexibility is useful for complex apps.

Deployment
Vite apps can be deployed in multiple ways:

Static Hosting
The built dist folder can be directly deployed to any static hosting service like Netlify or Vercel.

Server-Side Rendering
For SSR with Node or Deno servers, Vite provides SSR helpers and Nuxt.js integrations.

Conclusion

Vite enables rapid front-end development by leveraging native ESM imports. With its fast dev server, HMR, and optimized builds, it's a great choice for modern web apps. The intuitive project scaffolding, familiar workflow, and rich plugin ecosystem further make Vite a go-to build tool.

What is the difference between Vite and Webpack?

Vite uses native ESM imports and serves source code over a dev server. Webpack bundles all code into static assets during development. Vite has faster startup and HMR.

How does Vite achieve fast HMR?

Vite maintains a persistent WebSocket connection to the browser to handle HMR updates. Code changes are streamed over this connection, avoiding full browser refreshes.

Can Vite be used with existing projects?

Yes, Vite can replace the build setup in most existing projects with its framework integration. For React, the @vitejs/plugin-react plugin handles JSX transformation similar to Babel.

What browsers does Vite support?

Vite supports browsers that implement native ESM imports (Chrome, Firefox, Edge). For legacy browser support, code is transpired, and polyfills are added during the build step.

Does Vite fully replace Webpack?

Vite is optimized for modern browser apps. For legacy browser support, integration with Webpack is still useful. The two can complement each other in some cases.

How to Save a Node.js Script

Janki Mehta — Mon, 06 Nov 2023 05:57:41 +0000

Node.js allows you to write JavaScript code that runs outside of a browser. This code is often saved in .js files that can be executed from the command line. Here are a few ways to save and run a Node.js script:

1. Create a .js File

To save a Node.js script, simply create a new text file with a .js extension. For example:

myScript.js

You can create this in any text editor like Visual Studio Code, Sublime Text, Atom, etc.

2. Add Node.js Code

In the .js file, write your Node.js code. For example:

const msg = 'Hello World';
console.log(msg);

This script logs "Hello World" to the terminal.

3. Save the File

Be sure to save the .js file in your project directory. For example, you may have a scripts folder where you save all your Node.js scripts.

4. Run the Script

To execute the script, open your terminal and navigate to the script directory. Then run:

node myScript.js

It will execute the code in myScript.js. You should see "Hello World" output to the terminal.

5. Export and Import Scripts

You can also export code from one script and import it into another file. For example:

// myFunctions.js
export const greeting = () => {
  console.log('Hello');
};

// main.js 
import { greeting } from './myFunctions.js';

greeting(); // Logs "Hello"

It allows you to organize your code into reusable modules.

Saving a Node.js script is as simple as creating a .js file and running it with node. This allows you to write and execute JavaScript code outside of the browser!