Add command 'listRemoteDockerProcess' and variable 'pickRemoteDockerProcess' (#4607, PR: #4617)
Ensure we only start one instance of OmniSharp server (PR: #4612)
Update OmniSharp version to 1.37.11
  Include timing info in logged responses (PR: omnisharp-roslyn#2173)
  Defend against null value in BuildErrorEventArgs (omnisharp-roslyn#2171, PR: omnisharp-roslyn#2172)
  Updated to all the latest .NET SDKs (PR: omnisharp-roslyn#2166)
  Add support for GoToDefinition on source-generated files (PR: omnisharp-roslyn#2170)
  Add V2 version of GotoDefinitionService (PR: omnisharp-roslyn#2168)
  avoid NRE when document is null (PR: omnisharp-roslyn#2163))

 

In this article, 10 best practices in async-await code in C# is discussed that you should keep in mind when  developing asynchronous code in .NET 

SQL Server 2022 Performance - Buffer Pool Scan 

Considering the significant performance improvements and the elimination of buffer pool scan issues in SQL Server 2022, upgrading your SQL Server environment to this latest version is highly recommended. 

 XQuery [query()]: The name "p" does not denote a namespace.

 /books/book[1]/title/chapter

 XQuery [query()]: 'order by' requires a singleton (or empty sequence), found operand of type 'xs:integer +'

We are happy to announce the availability of .NET 8, the latest LTS version of one of the world’s leading development platforms, starting today. .NET 8 delivers thousands of performance, stability, and security improvements, as well as platform and tooling enhancements that help increase developer productivity and speed of innovation 

Preview: The SQLite Llibrary as a .NET assembly
The latest pre-release of SQLitePCLRaw contains a new bundle package called SQLitePCLRaw.bundle_cil. This package is like SQLitePCLRaw's other "bundle" packages except that it involves no P/Invoke and no platform-specific shared libraries. Instead, bundle_cil provides the SQLite library as a pure .NET assembly which was compiled by Llama. 

var $table = $('#browsers-grid');
$table.dataTable({
      "bServerSide": true,
      "sAjaxSource": "/Home/GetBrowsers"
 });

^[1-5]$

/// <summary>
/// Class that encapsulates most common parameters sent by DataTables plugin
/// </summary>
public class jQueryDataTableParamModel
{
    /// <summary>
    /// Request sequence number sent by DataTable,
    /// same value must be returned in response
    /// </summary>
    public string sEcho { get; set; }
    /// <summary>
    /// Text used for filtering
    /// </summary>
    public string sSearch { get; set; }
    /// <summary>
    /// Number of records that should be shown in table
    /// </summary>
    public int iDisplayLength { get; set; }
    /// <summary>
    /// First record that should be shown(used for paging)
    /// </summary>
    public int iDisplayStart { get; set; }
    /// <summary>
    /// Number of columns in table
    /// </summary>
    public int iColumns { get; set; }
    /// <summary>
    /// Number of columns that are used in sorting
    /// /// </summary>
    public int iSortingCols { get; set; }
    /// <summary>
    /// Comma separated list of column names
    /// </summary>
    public string sColumns { get; set; }
}

public JsonResult GetBrowsers(jQueryDataTableParamModel param)
{
        IQueryable<Browser> allBrowsers = new Browsers().CreateInMemoryDataSource().AsQueryable();

        IEnumerable<Browser> filteredBrowsers;

        // Apply Filtering
        if (!string.IsNullOrEmpty(param.sSearch))
        {
                filteredBrowsers = new Browsers().CreateInMemoryDataSource()
                    .Where(x => x.Engine.Contains(param.sSearch)
                                       || x.Grade.Contains(param.sSearch)
                                       || x.Name.Contains(param.sSearch)
                                       || x.Platform.Contains(param.sSearch)
                    ).ToList();
                float f;
                if (float.TryParse(param.sSearch, out f))
                {
                    filteredBrowsers = filteredBrowsers.Where(x => x.Version.Equals(f));
                }
        }
        else
        {
                filteredBrowsers = allBrowsers;
        }

        // Apply Sorting
        var sortColumnIndex = Convert.ToInt32(Request["iSortCol_0"]);
        Func<Browser, string> orderingFunction = (x => sortColumnIndex == 0 ? x.Engine :
                                                            sortColumnIndex == 1 ? x.Name :
                                                            sortColumnIndex == 2 ? x.Platform :
                                                            sortColumnIndex == 3 ? x.Version.ToString() :
                                                            sortColumnIndex == 4 ? x.Grade :
                                                                x.Name);

        var sortDirection = Request["sSortDir_0"]; // asc or desc
        filteredBrowsers = sortDirection == "asc" ? filteredBrowsers.OrderBy(orderingFunction) : filteredBrowsers.OrderByDescending(orderingFunction);

        // Apply Paging
        var enumerable = filteredBrowsers.ToArray();
        IEnumerable<Browser> displayedBrowsers = enumerable.Skip(param.iDisplayStart).
                Take(param.iDisplayLength).ToList();

        return Json(new
        {
                sEcho = param.sEcho,
                iTotalRecords = allBrowsers.Count(),
                iTotalDisplayRecords = enumerable.Count(),
                aaData = displayedBrowsers
        }, JsonRequestBehavior.AllowGet);
}

$(function () {
        var $table = $('#browsers-grid');
        $table.dataTable({
                "bProcessing": true,
                "bStateSave": true,
                "bServerSide": true,
                "bFilter": true,
                "sDom": 'T<"clear">lftipr',
                "aLengthMenu": [[5, 10, 25, 50, -1], [5, 10, 25, 50, "All"]],
                "bAutoWidth": false,
                "sAjaxSource": "/Home/GetBrowsers",
                "fnServerData": function (sSource, aoData, fnCallback) {
                    $.ajax({
                        "dataType": 'json',
                        "type": "POST",
                        "url": sSource,
                        "data": aoData,
                        "success": fnCallback
                    });
                },
                "aoColumns": [
                    { "mDataProp": "Engine" },
                    { "mDataProp": "Name" },
                    { "mDataProp": "Platform" },
                    { "mDataProp": "Version" },
                    { "mDataProp": "Grade" }
                ],
                "oLanguage": {
                        "sUrl": "/Content/dataTables.persian.txt"
                }
        });
});

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

pm.test("Status code is 200", function () {
    pm.expect(pm.response.code).to.equal(200);
});

pm.test("Request is successful", function () {
    pm.response.to.be.succes;
}); // Status code is in the 2XX range

pm.test("Request results in a client error", function () {
    pm.response.to.be.clientError;
}); // Status code is in the 4XX range

pm.test("Request results in a Not Found error", function () {
    pm.response.to.be.notFound;
}); // 404

pm.test("Status code is 200 or 204", function () {
    pm.expect([200, 204]).to.include(pm.response.code);
});

pm.test("Response has Content-Type header", function () {
    pm.response.to.have.header("Content-Type");
});

pm.test("Response has Content-Type header with application/json; charset = utf - 8 as value", function () {
    pm.response.to.have.header(
        'Content-Type',
        'application/json; charset=utf-8');
});

pm.test("Response has a non-empty body", function () {
    pm.expect(pm.response.text()).not.empty;
});

pm.test("Response has a non-empty body", function () {
    pm.expect(pm.response.json()).not.empty;
});

pm.test("Response has a non-empty body", function () {
    pm.response.to.have.body();
});

pm.test("Response has a non-empty body", function () {
    pm.response.to.have.jsonBody();
});

var updatedAuthor = pm.response.json();
pm.test("Author properties have been updated", function () {
    pm.expect(updatedAuthor.firstName).to.equal("Vahid");
    pm.expect(updatedAuthor.lastName).to.equal("N");
});

REACT_APP_NAME=My App
REACT_APP_VERSION=1

console.log(process.env);

console.log("My App Name", process.env.REACT_APP_NAME);

> npm install -g serve
> serve -s build

Access to XMLHttpRequest at 'https://localhost:5001/api/genres' from origin 'http://localhost:1234' has been blocked by CORS policy:
Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource.

WithOrigins("http://localhost:3000", "http://localhost:1234")

REACT_APP_API_URL=https://localhost:5001/api
REACT_APP_ADMIN_ROLE_NAME=Admin

const apiEndpoint = apiUrl + "/users";

const apiEndpoint =  "/users";

 axios.defaults.baseURL = process.env.REACT_APP_API_URL;

const adminRoleName =  process.env.REACT_APP_ADMIN_ROLE_NAME;