Why Architecture Matters More Than the Framework You Choose

Choosing the right framework is an important decision, but it rarely determines whether a web application succeeds. More often than not, long-term success depends on the architectural choices made before development begins. Teams that rush into coding without a clear plan frequently encounter performance bottlenecks, maintenance challenges, security gaps, and costly redesigns as their applications grow.

Blazor framework has matured into a powerful platform for building modern business applications. With Microsoft’s continued investment in .NET and Blazor Web Apps, organisations can now develop interactive, secure, and scalable applications using C# across both the frontend and backend. This unified development model reduces complexity while improving productivity.

Is Blazor the Right Choice for Your Business Application?

Not every application has the same technical requirements, which means there is no universal “best” framework. Before writing a single line of code, ask whether Blazor aligns with your business goals, team expertise, and long-term roadmap.

Blazor is particularly well suited for:

• Enterprise web applications
• Customer and employee portals
• Business process automation
• SaaS platforms
• Internal dashboards
• Applications already built on the Microsoft ecosystem

Because Blazor allows developers to use C# throughout the entire application, teams can reduce context switching between JavaScript and .NET. Existing business logic, validation, and shared libraries can often be reused, simplifying development and long-term maintenance.

A common question we hear is Blazor vs React. React remains an excellent choice for highly interactive public-facing applications with extensive JavaScript ecosystems. However, organisations already invested in .NET often find that Blazor offers a more streamlined development experience, particularly for enterprise software where maintainability, security, and developer productivity are priorities.

The right decision isn’t about following trends; it’s about selecting the framework that best supports your business objectives.

Choosing the Right Blazor Rendering Model for Your Project

Not every application has the same technical requirements, which means there is no universal “best” framework. Before writing a single line of code, ask whether Blazor aligns with your business goals, team expertise, and long-term roadmap.

Blazor is particularly well suited for:

• Enterprise web applications
• Customer and employee portals
• Business process automation
• SaaS platforms
• Internal dashboards
• Applications already built on the Microsoft ecosystem

Because Blazor allows developers to use C# throughout the entire application, teams can reduce context switching between JavaScript and .NET. Existing business logic, validation, and shared libraries can often be reused, simplifying development and long-term maintenance.

A common question we hear is Blazor vs React. React remains an excellent choice for highly interactive public-facing applications with extensive JavaScript ecosystems. However, organisations already invested in .NET often find that Blazor offers a more streamlined development experience, particularly for enterprise software where maintainability, security, and developer productivity are priorities.

The right decision isn’t about following trends; it’s about selecting the framework that best supports your business objectives.

Designing an Architecture That Can Scale with Your Business

Many applications perform well during their first few months. The real challenge begins when new features, additional users, third-party integrations, and growing datasets start increasing complexity.

Scalable architecture isn’t about preparing for millions of users on day one; it’s about making decisions today that won’t become obstacles tomorrow.

Questions worth considering include:

• Will your application support multiple business locations?
• Could new customer portals be introduced later?
• Will mobile applications consume the same APIs?
• Are future integrations with ERP, CRM, or payment systems likely?

Thinking ahead allows you to build flexible service boundaries, modular features, and infrastructure that can evolve without requiring major rewrites.

For businesses investing in enterprise web application development, scalability should be viewed as an architectural strategy rather than simply adding more servers.

Planning Your Solution Structure Before Writing the First Line of Code

A well-organised solution makes every future enhancement easier.

One of the most common mistakes in software projects is allowing application layers to become tightly coupled. Business logic slowly spreads into UI components, data access becomes difficult to replace, and even small changes introduce unexpected bugs.

Instead, establish a clear project structure from the beginning.

Many experienced teams adopt patterns such as:

• Clean Architecture
• Vertical Slice Architecture
• Feature-based organisation
• Modular Monoliths for growing applications

Each approach has advantages depending on the project’s size and complexity, but they all share one objective: separating responsibilities so that individual parts of the application are easier to understand, test, and maintain.

At Zobi Web Solutions, we treat architecture planning as a critical phase of every Blazor web app development project. Investing time in the right structure early often reduces technical debt, simplifies testing, and enables faster feature delivery throughout the application’s lifecycle.

Rather than asking, “How quickly can we build this?” we encourage businesses to ask, “How easily can this application evolve over the next five years?” That shift in thinking often leads to better technology decisions and significantly lower long-term development costs.

Separating Business Logic from the User Interface

As Blazor applications grow, it’s tempting to place business rules directly inside components. While this might speed up early development, it quickly becomes difficult to maintain. UI components should focus on displaying information and handling user interactions, not validating business rules, managing workflows, or communicating directly with databases.

A better approach is to move business logic into dedicated services or application layers. This separation makes your code easier to test, reuse, and update without affecting the user interface.

For example, if pricing rules or approval workflows change, developers should need to update only the business layer rather than modify multiple UI components. This approach reduces duplication and keeps your application organised as new features are added.

Maintaining clear boundaries between presentation, business logic, and data access is one of the most valuable architectural decisions you can make for long-term maintainability.

Deciding How Your Blazor Application Will Communicate with Data and Services

Your application’s communication strategy affects far more than data retrieval; it influences scalability, security, integration capabilities, and future expansion.

Many enterprise applications rely on:

• REST APIs
• Minimal APIs
• GraphQL
• Third-party integrations
• Microservices
• Legacy enterprise systems

Even if your first release includes only a Blazor frontend and a single database, designing with APIs in mind provides flexibility for future requirements, such as mobile applications, partner integrations, or external customer portals.

Rather than tightly coupling the UI to the database, expose business capabilities through well-designed service layers. This allows different applications to consume the same functionality without duplicating business logic.

For organisations investing in enterprise web solutions, an API-first mindset often pays dividends as business requirements evolve.

Building Authentication and Authorisation That Grows with Your Application

Security shouldn’t be treated as a feature added near the end of development. It should influence architectural decisions from the very beginning.

Before development starts, consider questions such as:

• Who will access the application?
• Will there be multiple user roles?
• Will customers, employees, and administrators have different permissions?
• Will external identity providers like Microsoft Entra ID or Google Sign-In be required?

Authentication verifies user identity, while authorisation determines what users are allowed to do. Mixing these concerns often leads to unnecessary complexity and security risks.

Blazor integrates seamlessly with the ASP.NET Core security ecosystem, allowing organisations to implement robust authentication and authorisation models while maintaining a consistent development experience.

For businesses handling sensitive customer or operational data, building security into the application’s architecture is significantly more effective than retrofitting it later.

Creating Reusable Components Instead of Repeating Code

One of Blazor’s greatest strengths is its component-based architecture, but simply creating components isn’t enough. The goal is to design components that are reusable, flexible, and easy to maintain.

Instead of creating multiple versions of similar forms, tables, or dashboards, consider building a shared component library with configurable behaviours. This creates consistency across the application while reducing development time for future features.

Reusable components also make collaboration easier across development teams. New functionality can often be assembled from existing building blocks rather than developed from scratch.

For companies planning multiple products or internal systems, investing in reusable UI components can significantly improve long-term productivity and consistency.

Making Performance Decisions Early Instead of Fixing Problems Later

Performance shouldn’t be optimised only after users begin reporting issues. Many performance problems originate from architectural decisions made during the planning stage.

Some areas worth considering include:

• Efficient rendering strategies
• Lazy loading where appropriate
• Data virtualisation for large datasets
• Intelligent caching
• Optimised API communication
• Reducing unnecessary component re-rendering

Another consideration is choosing the right rendering model for each part of the application. Not every page requires the same level of interactivity, and modern Blazor allows developers to tailor rendering strategies to different user experiences.

AI-assisted development tools have also begun changing how development teams approach optimisation. Rather than replacing experienced developers, AI helps identify potential bottlenecks, suggest improvements, generate repetitive code, and accelerate testing. Combined with experienced architectural oversight, these tools can shorten development cycles while maintaining code quality.

At Zobi Web Solutions, we view AI as an accelerator, not a replacement for engineering expertise. Our senior developers use AI-powered development tools to automate repetitive tasks, validate implementation patterns, and prototype features more efficiently, freeing up time to focus on architecture, performance, and complex business challenges. This balanced approach enables us to deliver Blazor development services that are faster, more consistent, and better aligned with each client’s long-term objectives.

Preparing Your Blazor Application for Cloud Deployment and Scalability

A successful launch is just the beginning. As your user base grows, your application should be able to handle increased traffic, new features, and evolving business requirements without major architectural changes.

Before development begins, think about where your application will be hosted and how it will scale. Whether you’re deploying on Microsoft Azure, AWS, or another cloud platform, your infrastructure should support automated deployments, load balancing, monitoring, and disaster recovery.

It’s also worth planning your CI/CD (Continuous Integration and Continuous Deployment) pipeline early. Automated testing and deployment not only reduce manual effort but also help deliver updates faster with greater confidence.

A cloud-ready architecture gives your business the flexibility to grow without having to rebuild the application every time requirements change.

Designing for Security, Monitoring, and Long-Term Maintenance

Building the application is only part of the journey. Keeping it secure, reliable, and maintainable over the coming years is equally important.

A well-designed Blazor application should include:

• Centralized logging
• Performance monitoring
• Exception handling
• Dependency management
• Security updates
• Health monitoring
• Regular code reviews

These practices help development teams identify issues before they affect users and simplify ongoing maintenance.

Long-term success also depends on documentation and coding standards. Clear architecture documentation makes onboarding new developers easier and reduces the risk of knowledge becoming isolated within a single team member.

When evaluating a Blazor or ASP. NET development company, consider how they approach maintenance after deployment, not just how quickly they can deliver the first release.

Future-Proofing Your Blazor Application for .NET Updates and Business Growth

Technology evolves quickly, and your application should be designed to evolve with it.

Microsoft continues to invest heavily in the Blazor framework, introducing new rendering capabilities, performance improvements, and productivity enhancements with each .NET release. Applications built with clean, modular architectures are far easier to upgrade than those with tightly coupled codebases.

Future-proofing also means preparing for business growth. New integrations, AI capabilities, reporting modules, customer portals, or mobile applications shouldn’t require rebuilding your entire system.

The goal isn’t to predict every future requirement; it’s to create an architecture flexible enough to accommodate change with minimal disruption.

Common Architecture Mistakes That Delay Blazor Projects

Many project delays have little to do with Blazor itself. Instead, they stem from architectural decisions that were overlooked during planning.

Some of the most common mistakes include:

• Choosing a rendering model without understanding its long-term impact.
• Mixing business logic directly into Blazor components.
• Building tightly coupled applications that are difficult to scale.
• Ignoring API design until third-party integrations become necessary.
• Treating performance optimisation as a post-launch activity.
• Underestimating authentication, authorisation, and security requirements.
• Starting development without a clear deployment or monitoring strategy.

Avoiding these pitfalls early often saves significant time, cost, and technical debt later in the project.

Blazor Architecture Checklist Before You Start Development

Before your development team writes the first line of code, make sure you’ve answered these questions:

•  Is Blazor the right framework for your business goals?
•  Have you selected the most suitable rendering model?
•  Does your application architecture support future growth?
•  Have you chosen a maintainable solution structure?
•  Is your business logic separated from the UI?
•  Is your API strategy clearly defined?
•  Have authentication and authorisation been planned?
•  Are reusable components part of your design approach?
•  Have you considered performance from day one?
•  Is your cloud deployment strategy finalised?
•  Do you have monitoring and maintenance processes in place?
•  Is the application designed for future .NET upgrades?

If several of these questions remain unanswered, it’s worth investing time in architecture planning before development begins.

Frequently Asked Questions

Is Blazor suitable for enterprise web applications?

Yes. Blazor is well suited for enterprise applications that require strong security, scalability, and seamless integration with the Microsoft .NET ecosystem. It’s an excellent choice for internal systems, customer portals, SaaS platforms, and business process automation.

Which Blazor rendering model should I choose?

The answer depends on your application’s requirements. Interactive Server, Interactive WebAssembly, Interactive Auto, and Static SSR each have different strengths. Selecting the right model should be based on user experience, scalability, hosting requirements, and application complexity.

Is Blazor better than React for business applications?

Neither framework is universally better. React offers a mature JavaScript ecosystem, while Blazor enables full-stack development with C# and .NET. For organisations already invested in Microsoft technologies, Blazor often provides a more unified and maintainable development experience.

Should I hire a Blazor development company?

If you’re building a business-critical application, working with an experienced team can reduce architectural risks, improve code quality, and accelerate delivery. A specialised partner can also help validate technology decisions before development begins.

How can Zobi Web Solutions help with Blazor development?

At Zobi Web Solutions, we help businesses plan, design, and build secure, scalable Blazor applications that align with long-term business objectives. From architecture consulting and enterprise web application development to modernisation and ongoing support, our team focuses on creating maintainable software built for growth.

Great Blazor Applications Start with Great Architecture

The success of a Blazor project isn’t determined by how quickly development begins; it’s determined by the quality of the decisions made before it starts.

Choosing the right rendering model, structuring your solution properly, designing secure APIs, planning for scalability, and preparing for future growth all contribute to an application that remains reliable and maintainable for years to come.

Whether you’re developing a new enterprise platform or modernising an existing .NET application, investing in architecture early can significantly reduce future costs while improving long-term outcomes.

Partner with Zobi Web Solutions

Building a successful Blazor application requires more than choosing the right framework; it requires thoughtful architecture, experienced engineering, and a clear understanding of your business goals.

At Zobi Web Solutions, we specialise in Blazor web app development, enterprise web solutions, and custom .NET applications that are designed for performance, scalability, and long-term maintainability. As a trusted web app development company and ASP.NET development company, we help businesses make confident technology decisions before development begins, reducing risk and setting projects up for long-term success.

If you’re planning a new Blazor application or evaluating an existing one, we’d be happy to help. Schedule a free Blazor architecture consultation with our team to discuss your goals, review your technical approach, and identify opportunities to build a more scalable and future-ready solution.

The post 12 Architecture Decisions You’ll Face Before Building a Blazor Web Application appeared first on Enterprise Web Solutions & AI Development Company .

Every .NET professional is aware of the new update. Some may not know the exact changes released in the new .NET 8. But this time, .NET proves why it is the best option for creating reliable web applications. .NET 8, scheduled for release in November 2023, marks many enhancements. The next long-term support (LTS) version of the framework. With each iteration, .NET pushes to be more advanced in performance, productivity, and security, and .NET 8 is no exception.

This .NET new features release comes with several improvements designed to make .NET developers’ lives easier while boosting productivity and offering a more seamless experience. From enhanced Blazor development capabilities to significant strides in DevOps and observability, the new features in .NET 8 are poised to transform the way developers build .NET applications, deploy, and maintain .NET applications.

Early reactions from .NET professionals have been overwhelmingly positive. Developers highlight the impact of these features on the efficiency of enterprise-level applications. Many believe .NET 8 will offer a more robust toolset for modern app development, giving them the ability to ship faster and ensure long-term stability.

New Features and How They Can Transform Your Development

1. The New .NET Long-Term Support (LTS) Release

The LTS release means that developers using .NET 8 will receive three years of support, including fixes, updates, and security patches. This ensures that businesses relying on .NET for critical applications can enjoy long-term stability and security with no immediate need for frequent updates. This version will be particularly valuable for large enterprises looking for a stable and dependable framework to support their business processes.

The LTS designation also signals that Microsoft views .NET 8 as a milestone release, packed with features that will be foundational for years to come. This gives developers confidence that the effort they put into upgrading their applications will pay off over an extended period.

2. Blazor Update: Enhanced Web Development

Blazor has been a standout feature since its introduction, allowing developers to build interactive web applications using C# instead of JavaScript. With .NET 8, Blazor takes a significant leap forward.

The key updates include improved performance, better component rendering, and expanded Hybrid Blazor functionality, which allows developers to build cross-platform apps with a shared codebase across web and desktop. The ability to combine server-side Blazor and client-side Blazor in a single application increases development flexibility. This makes .NET 8 a compelling option for developers looking to streamline their application-building processes while maintaining high-performance standards.

This update further strengthens Blazor’s position as a viable alternative to JavaScript-based frameworks, helping developers leverage their C# skills across more platforms.

3. System.Text.Json Serialization and Deserialization

Serialization and deserialization are critical to the efficient transfer of data in web applications. In .NET 8, System. Text. JSON gets a major performance boost. Microsoft has focused on minimizing memory usage and optimizing the serialization of large and complex data types.

.NET 8 introduces source generators for serialization, which help developers generate serialization code at compile time. This results in better runtime performance, especially for large applications. With these enhancements, developers can expect faster and more reliable data exchanges in their apps, leading to improved user experiences.

4. Built-in Support for Additional Types

.NET 8 now comes with integrated support for data types, which helps lessen reliance on libraries and manual solutions. The introduction of DateOnly and TimeOnly alongside reference types streamlines the handling of intricate data in present-day applications. This enhancement enhances the type safety of applications by minimizing the likelihood of errors and bugs resulting from type handling.

.NET 8 promotes developers to create more effective code by enhancing its built-in support and streamlining the management of libraries.

5. DevOps Improvements

One of the core focuses of .NET 8 is making it easier to integrate with modern DevOps pipelines. This release introduces new tools and APIs for better CI/CD integration. Microsoft has enhanced the interaction between .NET applications and popular DevOps tools like GitHub Actions and Azure DevOps, streamlining the deployment process and making automation more seamless.

By focusing on containers and cloud-native development practices, .NET 8 helps developers reduce the time spent on manual deployment processes, improve app resilience, and ensure smoother production releases. The result is a more agile and DevOps-friendly environment for managing application lifecycles.

6. Improved Diagnostics and Observability

With .NET 8, developers can better track performance bottlenecks and monitor system health thanks to enhanced diagnostic tools. These improvements include:

• Extended telemetry support
• Enhanced EventPipe for low-overhead diagnostics
• Better integration with OpenTelemetry for distributed tracing and monitoring

These tools help developers gain deeper insights into how their applications behave in real-time. They also make it easier to identify issues in production environments, reducing downtime and improving application reliability. The focus on observability empowers teams to maintain better control over their applications’ performance, leading to faster troubleshooting and more efficient operations.

.NET 8 vs. .NET 7: What’s Different?

LTS (Long-Term Support)

• NET 8: Offers long-term support (LTS) with three years of updates, fixes, and patches.
• .NET 7: A standard-term release with only 18 months of support, requiring quicker upgrades for ongoing updates.

Blazor Enhancements

• .NET 8: Brings Hybrid Blazor to enable cross-platform app development, along with significant performance improvements and better component rendering.
• .NET 7: Provided Blazor updates but lacked the hybrid capabilities and performance improvements seen in .NET 8.

How .NET 8 Improves DevOps and Monitoring

.NET 8 has enhanced DevOps workflows by integrating built-in container support and closer connections with cloud platforms to make deployment across environments easier for developers using services like Azure Kubernetes Service (AKS).

When it comes to keeping an eye on things, in .NET 8, there’s logging in place along with distributed tracing and metrics gathering to help teams keep track of the health of their applications across systems. These enhancements contribute to incident handling and improved performance of the system.

What’s New in .NET 8 for Developers?

Developers see .NET 8 as a step in terms of flexibility and performance, along with scalability improvements too! The added cross-platform development support is a game changer with serialization features and an improved DevOps pipeline that makes delivering applications easier, with reduced manual workloads.

The enhancements made to Blazor and System. Text. JSON, alongside the tools, will revolutionize the approach developers take in crafting and managing their code projects; additionally, the focus on LTS promises stability for long-term project maintenance.

Final Thoughts from .NET Professionals

Many .NET experts are excited about the potential of .NET 8 to transform enterprise application development. In particular, developers appreciate the expanded Blazor capabilities, the DevOps improvements, and the enhanced diagnostic tools that make production monitoring more effective.

Overall, .NET 8 is poised to become a cornerstone of modern software development. By offering a more developer-friendly, high-performance framework with long-term support, this release stands to boost productivity and deliver tangible benefits to development teams worldwide.

The post What’s New in .NET 8? New Features and How They Can Transform Your Development appeared first on Enterprise Web Solutions & AI Development Company .

In the Web and Application Development world, we can find many frameworks and development languages that programmers could choose from. Every framework has its own different sets of features and benefits that separate them. Today, we are going to discuss ASP.NET and ASP.NET Core to understand what benefits we can get out of using it.

ASP.NET

ASP.NET is an Open Source, Server-Side Web Application framework developed by Microsoft. It was launched in the early 2000s and it runs on the Windows platform. ASP.NET helps with the development of Web Applications, Web Services, and Dynamic Websites.

ASP.NET Core

ASP.NET Core is the latest version of ASP.NET which is platform-independent. This means it can run on every major platform such as Linux, MacOS, and Windows. ASP.NET Core was launched in 2016 and it is also an open-source developed by Microsoft and helps with the development of Web Applications, Web Services, and Dynamic Websites.

Why ASP.NET?

1. All in Itself: ASP.NET is a basic implementation of the .NET Framework for development of the Web Services and Websites. We can create any number of projects and can run on the same server. Most of the major companies are having their system running on ASP.NET for better control.
2. Individual and Enterprise: ASP.NET has something included for everyone for the individuals as well as the companies. For Small businesses, we can always use Web Pages to develop and as the business grows, ASP.NET allows us to use the MVC model which helps in the development of Web Application. We can easily edit Models, Views, and Controllers to change the content of Application.
3. Security: ASP.NET is a more secure framework than many of its competitors. ASP.NET has its own methods which make it better and secure. SQL Injection can be prevented using the SqlParameters, that allow us to minimize the injection.
   ASP.NET has security namespace which is used to define methods that can be used to protect the system.
4. Less Code, More Features: ASP.NET allows us to write fewer lines of codes and has many more functions, like JQuery in Javascript.
5. Community: In case of bottlenecks faced during development, there are many established communities of developers who are readily available to help out on various portals such as Stack Overflow, Social MSDB Forums, Code Project, etc.

Conclusion

We have shared a few of the important details necessary to influence your choice for Web development Strategy but it is definitely not everything. There are many more benefits to identify before selecting the right technology. Before that, it is important to outline and define the scope of work. Once the outline is ready it becomes easier to identify the right technology. Another best decision is to consult our team at Zobi Web Solutions which is exclusively working on ASP.NET development to assist you with decision making.

For further questions, feel free to connect us!!!

The post Why use ASP.NET for the web app development? appeared first on Enterprise Web Solutions & AI Development Company .

The main reason to use .NET core is that you can run it on multiple platforms and architectures. That’s why you can build an application that can be run on Windows, MacOS, Linux, and other different operating systems and architectures.

In this article, you will learn about many reasons for using the .NET Core. In this article, we will show you to create a simple .NET Core application that that’s able to run on multiple operating systems. To work with the demo as this article you should run your computer on Windows 10 operating system you have to install Visual Studio 2017 and .NET Core 2 SDK.

Additionally, if you want to run your app on MacOS you will need access to running MacOS 10.12 or any latest version.

.NET Core App Deployment Options

You can deploy .NET Core applications as framework-dependent applications and also as self-contained applications. There are mainly two deployment models and there are some differences between them.

Framework dependent applications :

It is essential to install the .NET Core framework in the system that can run the app.

Framework dependent application can run on any operating system on which you install .NET Core without any modifications.

Self-Contained applications :

Self-Contained applications do not need to install any .NET Core framework because it contains everything that the app needs to run.

For every operating system that you want a self-contained app to run on, you have to publish an Operating System specific version.

How to Create Application for multiple Operating System

Now, after knowing the two different deployment options, let’s explore to use those options to run a .NET Core application on multiple operating systems. We explain you about to create a demo .NET Core applications and run that on Windows and Mac Operating System.

We will create the .NET Core application using Visual Studio 2017. This is technically not essential as you can create .NET Core applications with different IDE and command line. Choose any of one from both of them that you are comfortable most.

Framework Dependent Application

First, we will create a framework dependent app. We do this in Visual Studio 2017 with the version 15.5.2.

So, you can follow the following steps.

1) In visual studio -> Click File -> New Project -> .NET Core.
Then select the console app and create it.

2) Navigate to program.cs and it will let you write “Hello World!”.
Add Console.RedLine(); below the “Hello” line to keep open the console window at the time of running of the application.

Self Contained Application

In this step, we will contain the application. This is similar to create a framework dependent app but with one extra step.

For that, you can follow the following steps.

1) In visual studio -> Click File -> New Project -> .NET Core.
Then select the console app and create it.

2) Navigate to program.cs and it will let you write “Hello World!“.
Add Console.RedLine(); below the “Hello” line to keep open the console window at the time of running of the application.

3) Now for the extra step to make this in a self-contained app right-click on the project file and click on the “End Project”.

Now in the project file add a line as per following in <propertyGroup>

<RintimeIdentifiers>win10-x64</RintimeIdentifiers>

This will tells .NET Core which runtimes it can be built and published to create self-contained apps. Like this, the application can only be published for Windows 10.

Running the Application on Windows and MacOS

Now, after this, we have two .NET Core applications, we need to publish them, as you would do in production, to get a release build. We can follow the same steps for Windows applications.

• Right Click on Project File in Visual Studio and click on Publish.
• Then you can pick a folder and click publish.
• Do the same for the Self-contained app.

Publishing for Run on MacOS

We should not do anything special steps to running the app on MacOS. We can just use the previous steps. If you need the self-contained app to run on anything then you need to perform some additional steps.

• Right Click on PROJECT File of a self-contained app in visual studio and click on Edit Project to edit the project file.
• Now add a new RuntimeIdentifiers to the file and save it as follows.

<RuntimeIdentifiers>win10-x64;osx.10.12-x64<RuntimeIdentifiers>

• Now right-click on Project file and click Publish.
• Click on a setting link In a publish overview.
• This will opens a profile setting popup, you make sure that you have selected the target runtime osx.10.12-x64.
• Change the target location to another folder so you can differentiate between the published results for Windows and MacOS.
• Click on Save and then click on Publish.

Running the Application on Windows

Now, you have the following publish results.

Results for the Framework Dependent App.

Results for self-contained App for windows and MacOS.

Let’s run the Framework Dependent Application on Windows Operating System.

• Open Windows Explorer.
• Navigate to the folder that contains the published results for the framework dependent app.
• Now go to the navigation bar and type “cmd” before the path and press enter. This will opens command prompt with the context of a folder. And make sure that this will only work with windows 10.
• Now type dotnetFrameworkDependentApp.dll.
• Now you will see “Hello World!” on command prompt window as an output.

Now, we are going to run a self-contained app. This is easy because it contains all the necessary things that need to run the application. This is the means that it has a packaged that app and .NET Core and an exe file that you need to run.

• Navigate to the folder with publishing results for the self-contained application for windows.
• Double-click the SelfContainedApp.exe.
• The app runs and shows “Hello World!” in a command window.

Running the Application on MacOS

The process to run the app on MacOS is very similar to Windows. Let’s show the steps for running an app on MacOS.

Framework Dependent App run on MacOS

• First, you need to install .NET Core framework dependent app on MacOS. You do not need to install SDK, you need the only runtime.
• Now, open the terminal window.
• In the terminal window, navigate to the folder which contains framework dependent app files.
• Then Type dotnetFrameworkDependentApp.dll in the Terminal Window and press the enter.
• Now, this app will run and show “Hello” on the terminal screen.

Self-contained App run on MacOS

Execute the following steps to run self-contained app on MacOS.

• First open a terminal window.
• In the terminal window, navigate to the folder that contains self-contained app files.
• Then type sudo chmod + x selfcontainedapp and press enter.
• Type in password of your admin account and press enter to grant permission to run the app.
• Now type in open selfcontainedapp and press enter.
• Now the app will run and shows “Hello” in the new terminal window.

Like this, you can make and run .NET Core App on different Operating Systems.

Conclusion

One of the main advantages of .NET Core is that you can use it to run an application on multiple platforms. It is very simple to create a framework dependent application that can run on multiple platforms. In order to run, It only needs .Net Core runtime to be installed. If you are a .NET developers or an ASP.NET Development Company then you need to know about to build cross-platform .NET Core apps.

The post Build cross platform .NET Core apps appeared first on Enterprise Web Solutions & AI Development Company .