We’re excited to share all the new features and improvements in .NET 8 Preview 4! This release is a follow-up to the Preview 3 release. You’ll continue to see many more features show up with these monthly releases. .NET 6 and 7 users will want to follow this release closely since we have focused on making it a straightforward upgrade path.
Visual Studio for Mac has parted ways with the Mono runtime in the just-published Preview 5, now running on .NET 6.
Results and Impact
- Average Latency improved from 350ms to less than 250ms.
- CPU during peak time was [60–40%]. This dropped to [15–25%].
- AWS Cost Reduction by replacing Windows with Linux servers [by 45%]
- Apache benchmarking [89 vs. 57 req/s]: .NET Core — 89.68 requests / second. .NET Framework on Windows — 57.21 requests/second
- JMeter [Throughput — 142.9 vs. 60.5 per second]: .NET Core Solution: Hit 1000 requests on http://XXXX.redbus.pe/ , Throughput was 142.9/Sec. NET Framework on Windows: Hit 1000 requests on http://XXXX.redbus.pe/, Throughput was 60.5/Sec.
- Blazemeter [90% response time — 417ms vs. 1.09s]: .NET Core Solution: 90% Response time was 417ms. .NET Framework on Windows: 90% Response time was 1.09s.
services.AddDbContext<ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")
)); "ConnectionStrings": {
"ConnectionTemplate": "Data Source=.;Initial Catalog={db_Name};Integrated Security=True",
} services.AddDbContext<ApplicationDbContext>((serviceProvider, dbContextBuilder) =>
{
var connectionStringTemplate = Configuration.GetConnectionString("ConnectionTemplate");
var httpContextAccessor = serviceProvider.GetRequiredService<IHttpContextAccessor>();
var dbName = httpContextAccessor.HttpContext.Request.Headers["tenantId"].First();
var connectionString = connectionStringTemplate.Replace("{db_Name}", dbName);
dbContextBuilder.UseSqlServer(connectionString);
}); 
Hello%20world%20,%20hi
<html>encoding</html>
<html>encoding</html>
| کاراکتر | عبارت معادل | توضیحات |
| > | > | |
| < | < | |
| " | " | |
| ' | ' | یا ;apos& به غیر از IE |
| & | & |
public static unsafe void HtmlEncode(string value, TextWriter output)
{
int index = IndexOfHtmlEncodingChars(value, 0);
if (index == -1)
{
output.Write(value);
return;
}
int cch = value.Length - index;
fixed (char* str = value)
{
char* pch = str;
while (index-- > 0)
{
output.Write(*pch++);
}
while (cch-- > 0)
{
char ch = *pch++;
if (ch <= '>')
{
switch (ch)
{
case '<':
output.Write("<");
break;
case '>':
output.Write(">");
break;
case '"':
output.Write(""");
break;
case '\'':
output.Write("'");
break;
case '&':
output.Write("&");
break;
default:
output.Write(ch);
break;
}
}
else if (ch >= 160 && ch < 256)
{
// The seemingly arbitrary 160 comes from RFC
output.Write("&#");
output.Write(((int)ch).ToString(NumberFormatInfo.InvariantInfo));
output.Write(';');
}
else
{
output.Write(ch);
}
}
}
}
private static unsafe int IndexOfHtmlEncodingChars(string s, int startPos)
{
int cch = s.Length - startPos;
fixed (char* str = s)
{
for (char* pch = &str[startPos]; cch > 0; pch++, cch--)
{
char ch = *pch;
if (ch <= '>')
{
switch (ch)
{
case '<':
case '>':
case '"':
case '\'':
case '&':
return s.Length - cch;
}
}
else if (ch >= 160 && ch < 256)
{
return s.Length - cch;
}
}
}
return -1;
}<div id="log"></div>
<script type="text/javascript">
var element = document.getElementById('log');
element.innerText = '<html> encoding </html>';
console.log(element.innerHTML);
</script><html> encoding </html>
<div id="log">
</div>
<script type="text/javascript">
var element = document.getElementById('log');
element.innerHTML = "<html> encoding </html>";
console.log(element.innerText);
</script><html> encoding </html>
String.htmlEncode = function (s) {
var el = document.createElement("div");
el.innerText = s || '';
return el.innerHTML;
};console.log(String.htmlEncode("<html>"));
//result: <html>String.prototype.htmlEncode = function () {
var el = document.createElement("div");
el.innerText = this.toString();
return el.innerHTML;
};console.log("<html>".htmlEncode());
//result: <html>String.htmlDecode = function (s) {
var el = document.createElement("div");
el.innerHTML = s || '';
return el.innerText;
};String.prototype.htmlDecode = function () {
var el = document.createElement("div");
el.innerHTML = this.toString();
return el.innerText;
};console.log(String.htmlDecode("<html>"));
console.log("<html>".htmlDecode());String.htmlEncode = function (s) {
return $('<div/>').text(value).html();
};
String.prototype.htmlEncode = function () {
return $('<div/>').text(this.toString()).html();
};String.htmlDecode = function (s) {
return $('<div/>').html(s).text();
};
String.prototype.htmlDecode = function () {
return $('<div/>').html(this.toString()).text();
};var value = "a \n b";
String.htmlEncode = function (s) {
var el = document.createElement("div");
var txt = document.createTextNode(s);
el.appendChild(txt);
return el.innerHTML;
};String.htmlDecode(String.htmlEncode(myString)) === myString;
var myString = "<HTML>"; String.htmlDecode(String.htmlEncode(myString)) === myString; // result: true // -------------------------------------------------------------------------- myString = "<اچ تی ام ال>"; String.htmlDecode(String.htmlEncode(myString)) === myString; // result: true
myString = "a \r b"; String.htmlDecode(String.htmlEncode(myString)) === myString; // result: false
console.log(escape(String.htmlDecode('\r'))); // result: %0A : it is url encode of character '\n'
console.log(escape(String.htmlDecode('\n'))); // result: %0A
console.log(escape(String.htmlDecode('\r\n'))); // result: %0Avar el = document.createElement('div');
el.innerText = '\r';
console.log(escape(el.innerText)); // result: %0A
el.innerHTML = '\r';
console.log(escape(el.innerHTML)); // result: %0A
console.log(escape('\r')); // result: %0DString.htmlEncode = function (text) {
text = text || '';
var encoded = '';
for (var i = 0; i < text.length; i++) {
var c = text[i];
switch (c) {
case '<':
encoded += '<';
break;
case '>':
encoded += '>';
break;
case '&':
encoded += '&';
break;
case '"':
encoded += '"';
break;
case "'":
encoded += ''';
break;
default:
// the upper limit can be removed to support more chars...
var code = c.charCodeAt();
if (code >= 160 & code < 256)
encoded += '&#' + code + ';';
else
encoded += c;
}
}
return encoded;
};function escapeHTML() {
return this.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
}
function unescapeHTML() {
return this.stripTags().replace(/</g, '<').replace(/>/g, '>').replace(/&/g, '&');
}var andExp = /&/g,
htmlExp = [/(<|>|")/g, /(<|>|')/g, /(<|>|'|")/g],
htmlCharMap = { '<': '<', '>': '>', "'": ''', '"': '"' },
htmlReplace = function (all, $1) {
return htmlCharMap[$1];
};
$.extend({
// convert special html characters
htmlspecialchars: function (string, quot) {
return string.replace(andExp, '&').replace(htmlExp[quot || 0], htmlReplace);
}
});$.htmlspecialchars("<div>");this.escapeHTML = function (s) {
this.str = this.s(s)
.split('&').join('&')
.split('<').join('<')
.split('>').join('>');
return this;
};
this.unescapeHTML = function (s) {
this.str = this.stripTags(this.s(s)).str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>');
return this;
};Modern software development practices value quick and continuous updates, following processes that minimize the impact of software failures. As important as identifying bugs early, finding out if changes are improving business value are equally important. These practices can only work when a monitoring solution is in place. This article explores options for adding observability to .NET Core apps. They have been collected based on interactions with customers using .NET Core in different environments. We will be looking into OpenTelemetry and Application Insights SDKs to add observability to a sample distributed application.
وب اسمبلی چیست؟
<BlazorMode> ... </BlazorMode> <WebAppDeploymentType> ... </WebAppDeploymentType>
Security in software development should be a first-order requirement, but it’s often implemented in projects as an afterthought. With Application Security in .NET Succinctly, author Stan Drapkin provides a refresher of .NET security practices and fills common knowledge gaps for experienced developers and novices alike. Learn about hashes, machine authentication code, key derivation, binary and text encodings, symmetric and authenticated encryption, and much more, and begin properly securing your .NET apps today.
With .NET Standard 2.0, we’re focusing on compatibility. In order to support .NET Standard 2.0 in .NET Core and UWP, we’ll be extending these platforms to include many more of the existing APIs. This also includes a compatibility shim that allows referencing binaries that were compiled against the .NET Framework.
