nowhere on the official documentation home site does it say anything about Core. Did they just rename it again? And if yes, why does it still say core in vscode templates?

I am on the side of skipping MVC and focusing only on learning Web Api. The primary reason as to why I want to skip learning MVC is that you don't need MVC because when you have your front-end ready in Angular then you can just return data using HTTP response from a Web Api and display it in your Angular frontend. So by using WebApi+Angular, I am actually getting MVC functionality and so why should I learn MVC?! What's even the point of MVC's existence?

Am I thinking wrong right now? Feel free to correct me as I am just an intern at a service based startup with zero year experience.

I have been trying to understand asp.net core auth for 3 weeks now. I don't want to do nothing exceptional, just a simple authentication with an external provider like Google. The configuration part? Yeah really simple I have no complains. The problem is what comes after? Naah, literally what comes next? I have configured the auth provider now what? Where do I go from that? It's sad that I have to rely on chatgpt to help, it sucks because I have to take a little from here and there. Like there's no straight guide documentation on what to do after the configuration like seriously. How am I supposed to know I need to use the http context.authenticate method when you guys don't provide any info about it? Do they do this on purpose? Had I know about this I wouldn't even have started studying this framework.

I have a "gaming" laptop from lenovo, which is totally cool for gaming and working while charging cable connected, however when i need to unplug it and go somewhere - it's not holding more than an hour. So, I'm planning to sell it and have a pair of stationary pc (mainly for gaming)+ macbook(work station). Will I encounter any difficulties in learning c#/asp.net on macOS?

I am curious as to what you guys prefer for your front-end. I would like to try C# and Angular, but I want to get suggestions from here first.

I hate Microsoft's inconsistency in naming. .NET Core has become .NET, but EF Core and ASP.NET Core are still called XX Core. Can't they find a way to unify the names? Every time I search or ask an AI without adding "Core" at the end, the results are different. It's very troublesome. ASP.net core, too long to type.

Hey guys

I've been playing around with different web frameworks and noticed that Asp.net is remarkably faster than everything else. For example, according to my tests on my laptop, minimal API is ~4x faster than running a server with Go's HTTP package.

So, my question is: Am I measuring something horribly wrong, or does Asp.net use black magic to achieve this kind of performance?

Here is my testing methodology:

The objective is to test only the framework's performance (not the logger or the db driver). So, for every language and framework, I wrote a simple HTTP server that returns a JSON encoded { "hello": "world" } object.

I ran those servers in docker containers with 0.5 CPUs and 300 MB of memory.

For benchmarking I used

autocannon -c 100 -d 30 -p 10 localhost:3000

Here are the exact results on my machine (MBP15 2018. 2,2 GHz 6-Core Intel Core i7)

Dotnet

┌─────────┬───────┬───────┬───────┬───────┬──────────┬──────────┬────────┐
│ Stat    │ 2.5%  │ 50%   │ 97.5% │ 99%   │ Avg      │ Stdev    │ Max    │
├─────────┼───────┼───────┼───────┼───────┼──────────┼──────────┼────────┤
│ Latency │ 10 ms │ 21 ms │ 85 ms │ 91 ms │ 37.89 ms │ 26.77 ms │ 115 ms │
└─────────┴───────┴───────┴───────┴───────┴──────────┴──────────┴────────┘
┌───────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┐
│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5%   │ Avg     │ Stdev   │ Min     │
├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
│ Req/Sec   │ 22927   │ 22927   │ 26191   │ 29023   │ 26065.6 │ 1534.87 │ 22927   │
├───────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┼─────────┤
│ Bytes/Sec │ 4.04 MB │ 4.04 MB │ 4.61 MB │ 5.11 MB │ 4.59 MB │ 270 kB  │ 4.04 MB │
└───────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┘

783k requests in 30.06s, 138 MB read

Go HTTP

┌─────────┬──────┬───────┬────────┬────────┬───────────┬───────────┬─────────┐
│ Stat    │ 2.5% │ 50%   │ 97.5%  │ 99%    │ Avg       │ Stdev     │ Max     │
├─────────┼──────┼───────┼────────┼────────┼───────────┼───────────┼─────────┤
│ Latency │ 1 ms │ 89 ms │ 610 ms │ 797 ms │ 152.06 ms │ 182.89 ms │ 1917 ms │
└─────────┴──────┴───────┴────────┴────────┴───────────┴───────────┴─────────┘
┌───────────┬────────┬────────┬────────┬────────┬────────┬─────────┬────────┐
│ Stat      │ 1%     │ 2.5%   │ 50%    │ 97.5%  │ Avg    │ Stdev   │ Min    │
├───────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┤
│ Req/Sec   │ 5927   │ 5927   │ 6463   │ 7415   │ 6511.2 │ 350.15  │ 5926   │
├───────────┼────────┼────────┼────────┼────────┼────────┼─────────┼────────┤
│ Bytes/Sec │ 794 kB │ 794 kB │ 866 kB │ 993 kB │ 872 kB │ 46.9 kB │ 794 kB │
└───────────┴────────┴────────┴────────┴────────┴────────┴─────────┴────────┘

196k requests in 30.04s, 26.2 MB read

Here is the with more results and the source code

Edit

I've found a Go framework called that uses instead of the default HTTP package. It seems to be even faster than (by ~50%)

┌─────────┬──────┬───────┬───────┬───────┬──────────┬──────────┬────────┐
│ Stat    │ 2.5% │ 50%   │ 97.5% │ 99%   │ Avg      │ Stdev    │ Max    │
├─────────┼──────┼───────┼───────┼───────┼──────────┼──────────┼────────┤
│ Latency │ 5 ms │ 13 ms │ 73 ms │ 79 ms │ 24.85 ms │ 21.97 ms │ 130 ms │
└─────────┴──────┴───────┴───────┴───────┴──────────┴──────────┴────────┘
┌───────────┬─────────┬─────────┬─────────┬───────┬──────────┬─────────┬─────────┐
│ Stat      │ 1%      │ 2.5%    │ 50%     │ 97.5% │ Avg      │ Stdev   │ Min     │
├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼─────────┼─────────┤
│ Req/Sec   │ 34047   │ 34047   │ 39903   │ 44831 │ 39413.34 │ 2456.15 │ 34022   │
├───────────┼─────────┼─────────┼─────────┼───────┼──────────┼─────────┼─────────┤
│ Bytes/Sec │ 4.56 MB │ 4.56 MB │ 5.35 MB │ 6 MB  │ 5.28 MB  │ 329 kB  │ 4.56 MB │
└───────────┴─────────┴─────────┴─────────┴───────┴──────────┴─────────┴─────────┘

1183k requests in 30.05s, 158 MB read

The point is that there is plenty of information in their readmes about how they achieved that performance.

1. Reuse of request and response objects with ring buffers

2. More efficient storage of headers

3. Using []byte instead of string where possible. The conversion is cheap but not free

4. Avoiding unnecessary allocations

5. =D

While this does not directly apply to it still shows what kind of "black magic" people use to gain performance.

Edit

If you can add to the list above something specific to or confirm that ASP does use something like to reuse requests and responses (or anything else with real examples) I would be grateful.

To clarify, the goal of this post is not to dunk on any framework or language. It's to find what cool things people are doing to go blazingly fast.

I'm looking for good examples that follow best practices to help me make an MVC app with basic database actions like create, read, update, and delete, but I don't want to use Entity Framework - I prefer sticking to just SQL. Most tutorials use entity framework, so I'm wondering if there are any examples that focus on SQL without ORM?

I'm a long-time developer who currently maintains several ASP.NET Core websites. A couple of those sites are in use 24x7.

Currently, the way I deploy these websites is publish from Visual Studio to a folder, I copy those files to a temp folder on the server, I take the site down by copying app_offline.htm to the site folder, and then manually copy all the files to the live website folder.

This works but the manual steps take longer than necessary and also leave room for me to make stupid mistakes.

I started thinking about writing a program to copy the files automatically? But it occurs to me that thousands of people are doing this already. So there must be well established techniques for doing this. Can someone offer some suggestions for how I might approach this, or direct me to some articles that discuss my options?

Note: I am not on Azure. I'm just running IIS on a virtual private server.

Thanks!

Original Post:

As a Full Stack ASP.NET Developer(platform Bing is Built on), I read this thread and saw a lot of blatant misinformation. I'd like to provide some advice on how to read network logs so that no one makes the same mistake.

OP posted an example of how Bing supposedly "preloads related searches":

As you see above, OP searches for "tacos" on Bing Images, and then there seems to be a lot of requests for related queries, such as "Chicken Tacos"

However, if you pay attention, you can clearly tell that those are not search queries, but rather, AJAX requests initiated by the page itself.

AJAX is basically a way for the client JavaScript to make requests to the server without reloading the page. This is how "endless scrolling" works, and also leads to faster, more responsive websites. It can also be used to load less important content such as images after the main page already loaded, improving UX.

Let's break down the urls, first by starting with the original search URL:

/images/ tells ASP.NET to look for the images "controller" which is a C# or VB class containing 1 or more methods

/search tells the controller to run the "Search" public method.

?q=tacos&form=HDRSC2 passes 2 parameters to the Search method. The first is obviously the query the user typed, the second doesn't really matter.

Next, let's look at the URL for one of the "automatically ran related searches"

th.bing.com First thing any sys admin should notice is this is an entirely different subdomain which should raise questions immediately.

th? it is calling the th controller at a completely different domain. Because no method is specified, it will run the index method

q=Mexican+Chicken+Tacos&w=166&h=68&c=1&rs=1&pid=InlineBlock&mkt=en-US&adlt=moderate&t=1

You can clearly see there are a LOT more parameters being passed here than the other query. Seeing w=166&h=68 should be a hint that these are parameters for an image.

What is happening here is after you search for tacos, there is AJAX that runs and sends a request to Bing to load the preview image for the related search query(in this case, a Chicken Taco). The reason Microsoft does this instead of just loading everything at once is because by requesting images AFTER the page has loaded, the page can load quicker rather than the user having to wait for everything.

In this particular case, the subdomain should've been a dead giveaway that it wasn't a search. But in some cases it's even possible that AJAX requests can use the same path. Through something called "overloading", the same URL can run a completely different method based on how many parameters are supplied.

So what's the key takeaway here?

1.When viewing logs, pay attention to both the subdomain and the parameters passed to determine if the user actually actively navigated to a link, or if the request is a result of AJAX scripting.

2.The presence of a concerning phrase in a POST/GET request is not inherent proof that a user is engaging in that type of content. For example, if you accidentally hover over a Reddit username, it performs an AJAX request to:

So if my username was something VERY NSFW, it would look like you were looking at a NSFW reddit user's profile, when in reality your mouse happened to pass over my username, but you never clicked it.

3.Bing is NOT automatically searching related searches, but they should stop recommending illegal search queries because it's just wrong

edit: I appreciate the support, but please don't Gild me as I dislike Reddit's management and direction. Instead please donate to or a charity of your choice instead.

I am currently interviewing for a role that mostly developed apps in webforms which I have no experience with. How much harder/easier will it take for me to pick up if I already know MVC?

Edit: Thanks everyone for confirming my thoughts on this subject. I am well aware this is going backwards in terms of tech stack. For what it’s worth, this role is for a city government job which means more stability especially in this job market. The only reason why it is appealing to me is that I can move back home closer to family but I know I will probably hate myself if I have to do outdated tech.

I've seen a lot of threads on this subreddit from users talking about building / Web applications using the improved AOT capabilities in .NET 8. I am confused as to why this is.

AOT in this context provides no real benefits, outside of improving cold startup times for serverless, and even then that benefit is really quite marginal in the grand scheme of things.

AOT's primary benefit is being able to building and distribute .NET applications without distributing the .NET runtime itself - that's very useful for distributing things like desktop + mobile + console applications. With AOT trimming you can also further reduce the binary size of the native executable, which makes sense for things like mobile applications that are being downloaded over metered bandwidth.

In a web environment where _you control the execution runtime of the application and the hardware it runs on_, however, there's not much benefit to doing this. .NET's JIT with Dynamic PGO enabled (which it is by default in .NET 8 now) will always produce better-performing code over the long run. On top of that, AOT reduces your options in terms of third party library support (i.e. no Newtonsoft) and some of your own code choices .

If you're looking at building an application and you currently plan on using AOT, why?

I work in an organization that, to put it bluntly, has no consistent or well-thought-out strategy for deciding and assigning version numbers to internal-facing applications.

My role is on a team developing with in .NET 8, and I'm in a position to implement a new strategy.

From a very high-level, I'd like to use an easy-to-understand method to ensure that I can look at a running app or the underlying exe and know the version number, and have that version number be referenced somewhere in the commit.

The most recent existing system I worked on implemented the version number as a manually incremented value (e.g. major.minor.patch.manually-incremented-build-number) assigned to AssemblyVersion and AssemblyFileVersion within AssemblyInfo.cs (it was on 4.8). This worked okay tbh, but there were many cases of the build number not being incremented because someone forgot before they committed.

What was nice about that approach it is that it's straightforward - the version is visible from File Explorer, it's visible from Assembly.GetExecutingAssembly().GetName().Version, and I suppose you can create a matching tag in Git to see the version there as well.

ChatGPT suggested a few different ideas, including GitVersion. I recognize there are many solutions to this and a lot probably integrate with the deployment pipeline in some way, but we don't really have much of one of those either...yet.

I just decided to learn c# but I'd like to now which is the difference between ASP.NET and .NET (If my english is wrong forgive me, I am a beginner on English yet)

Asking the community for their opinion on with HTMX. It looks like a great way to more tightly couple the backend with the front-end and solves a major problem of keeping the two in sync and avoiding the chaos of JavaScript client side libraries. Has anyone had good or bad experiences using it?

makeshift memorize desert cagey chop dolls narrow plucky wistful ghost

This post was mass deleted and anonymized with

Currently embarking on a new project and my gut reaction was to use MVC because after many, many years of writing ReactJS frontends with API's, I thought it'd be nice to fall back to something which is architecturally simpler.

Then I started thinking about what users expect from modern web user interfaces and quickly realised that I'd be reaching for tools like jQuery and effectively implementing a watered down WebAPI/JavaScript frontend, just without the "hard" segregation of frontend/backend.

Just looking for a sense check on my logic here - MVC + jQuery and ReactJS + WebAPI - both are valid approaches but is the former *really* saving time and complexity?

My company wants software migration from asp.net to asp.net core, can anyone suggest any YouTube videos or websites which may be helpful.

Hello, I am currently planning to make a web app, that will have a lot of user interactions, for example there will be a custom editor, that I would parse and realtime show a result, all of this will be able to run for multiple users at the same time, like lets say google docs..

To give you a little bit of context I am currently working as a fullstack typescript dev, and my plan was to switch to the .NET stack, as I've started hating typescript syntaxes, speeds and stuff.

Now I'm having a little bit too much of a decision fatigue, as it's really hard for me to choose between these frameworks(ASP.NET Core MVC, ASP and Blazor). What I've seen is that ASP.NET Core MVC is the industry standard, it's really structured and can be a lot bloated, it can perform server-side and client-side using razor or js frameworks which I wanted to avoid using js at all.
On the other side, Blazor seems a lot more appealing to me as it tries to eliminate the use of js, it can perform too server-side and client-side using WASM, I don't know if thats possible to do in the same project tho, that would be very beneficial, and looks easier to understand and is more concise. Why would someone prefer MVC looking at Blazor? I must be missing something.

Can someone help me like decide what would be the best choice for my usecase, overall tell me the advantages and disadvantages? I am really sorry if this comparison is being asked a lot, I have searched a bit and the sources that I found confused/overwhelmed me. All help is appreciated.