Once created, these custom elements -- a custom counter, for example -- can also be used in other single-page application (SPA) web frameworks such as React and Angular. A sample project, aptly titled Blazor Custom Elements, shows how to do just that, providing examples about how to work with those frameworks and the client-side Blazor WebAssembly component as well as Blazor Server.
Some key areas of focus uncovered by this investigation were:
Being mindful of memory allocations to minimize GC pause times
Keeping long-running calls non-blocking/asynchronous
Minimizing calls to external resources (such as other web services or the database) with caching and grouping of requests
using System.Collections.Generic;
namespace WpfTests.Hierarchy.Raw.Model
{
public class Person
{
private readonly List<Person> _children = new List<Person>();
public IList<Person> Children
{
get { return _children; }
}
public string Name { get; set; }
}
}
using System.Collections.ObjectModel;
namespace WpfTests.Hierarchy.Raw.Model
{
public class People : ObservableCollection<Person>
{
public People()
{
this.Add(
new Person
{
Name = "P1",
Children =
{
new Person
{
Name="P2",
Children=
{
new Person
{
Name="P3",
Children=
{
new Person
{
Name="P4",
}
}
}
}
}
}
}
);
}
}
}
<TreeView ItemsSource="{Binding People}">
<TreeView.ItemTemplate>
<HierarchicalDataTemplate ItemsSource="{Binding Children}">
<TextBlock Text="{Binding Name}" />
</HierarchicalDataTemplate>
</TreeView.ItemTemplate>
</TreeView>
{
"type": "https://example.com/probs/out-of-credit",
"title": "You do not have enough credit.",
"detail": "Your current balance is 30, but that costs 50.",
"instance": "/account/12345/msgs/abc",
"status": 403,
} var mediaType = response.Content.Headers.ContentType?.MediaType;
if (mediaType != null && mediaType.Equals("application/problem+json", StringComparison.InvariantCultureIgnoreCase))
{
var problemDetails = await response.Content.ReadFromJsonAsync<ProblemDetails>(null, ct) ?? new ProblemDetails();
// ...
} [HttpPost("/sales/products/{sku}/availableForSale")]
public async Task<IActionResult> AvailableForSale([FromRoute] string sku)
{
return Problem(
"Product is already Available For Sale.",
"/sales/products/1/availableForSale",
400,
"Cannot set product as available.",
"http://example.com/problems/already-available");
} HTTP/1.1 400 Bad Request
Content-Type: application/problem+json
Content-Language: en
{
"type": "https://tools.ietf.org/html/rfc7231#section-6.5.1",
"title": "One or more validation errors occurred.",
"status": 400,
"errors": {
"User": [
"The user name is not verified."
]
}
} namespace WebApplication.Controllers
{
[ApiController]
[Route("[controller]")]
public class DemoController : ControllerBase
{
[HttpPost]
public ActionResult Post()
{
var problemDetails = new ProblemDetails
{
Detail = "The request parameters failed to validate.",
Instance = null,
Status = 400,
Title = "Validation Error",
Type = "https://example.net/validation-error",
};
problemDetails.Extensions.Add("invalidParams", new List<ValidationProblemDetailsParam>()
{
new("name", "Cannot be blank."),
new("age", "Must be great or equals to 18.")
});
return new ObjectResult(problemDetails)
{
StatusCode = 400
};
}
}
public class ValidationProblemDetailsParam
{
public ValidationProblemDetailsParam(string name, string reason)
{
Name = name;
Reason = reason;
}
public string Name { get; set; }
public string Reason { get; set; }
}
} services.AddProblemDetails();
app.UseExceptionHandler();
app.UseStatusCodePages();
app.UseDeveloperExceptionPage();
builder.Services.AddProblemDetails(options =>
options.CustomizeProblemDetails = ctx =>
ctx.ProblemDetails.Extensions.Add("MachineName", Environment.MachineName)); public class MyErrorFeature
{
public ErrorType Error { get; set; }
}
public enum ErrorType
{
ArgumentException
} [HttpGet("{value}")]
public IActionResult MyErrorTest(int value)
{
if (value <= 0)
{
var errorType = new MyErrorFeature
{
Error = ErrorType.ArgumentException
};
HttpContext.Features.Set(errorType);
return BadRequest();
}
return Ok(value);
} services.AddProblemDetails(options =>
options.CustomizeProblemDetails = ctx =>
{
var MyErrorFeature = ctx.HttpContext.Features.Get<MyErrorFeature>();
if (MyErrorFeature is not null)
{
(string Title, string Detail, string Type) details = MyErrorFeature.Error switch
{
ErrorType.ArgumentException =>
(
nameof(ArgumentException),
"This is an argument-exception.",
"https://www.rfc-editor.org/rfc/rfc7231#section-6.5.1"
),
_ =>
(
nameof(Exception),
"default-exception",
"https://www.rfc-editor.org/rfc/rfc7231#section-6.6.1"
)
};
ctx.ProblemDetails.Title = details.Title;
ctx.ProblemDetails.Detail = details.Detail;
ctx.ProblemDetails.Type = details.Type;
}
}
); public class MyCustomException : Exception
{
public MyCustomException(
string message,
HttpStatusCode statusCode = HttpStatusCode.BadRequest
) : base(message)
{
StatusCode = statusCode;
}
public HttpStatusCode StatusCode { get; }
} [HttpGet("{value}")]
public IActionResult MyErrorTest(int value)
{
if (value <= 0)
{
throw new MyCustomException("The value should be positive!");
}
return Ok(value);
} app.UseExceptionHandler(exceptionHandlerApp =>
{
exceptionHandlerApp.Run(async context =>
{
context.Response.ContentType = "application/problem+json";
if (context.RequestServices.GetService<IProblemDetailsService>() is { } problemDetailsService)
{
var exceptionHandlerFeature = context.Features.Get<IExceptionHandlerFeature>();
var exceptionType = exceptionHandlerFeature?.Error;
if (exceptionType is not null)
{
(string Title, string Detail, string Type, int StatusCode) details = exceptionType switch
{
MyCustomException MyCustomException =>
(
exceptionType.GetType().Name,
exceptionType.Message,
"https://www.rfc-editor.org/rfc/rfc7231#section-6.5.1",
context.Response.StatusCode = (int)MyCustomException.StatusCode
),
_ =>
(
exceptionType.GetType().Name,
exceptionType.Message,
"https://www.rfc-editor.org/rfc/rfc7231#section-6.6.1",
context.Response.StatusCode = StatusCodes.Status500InternalServerError
)
};
await problemDetailsService.WriteAsync(new ProblemDetailsContext
{
HttpContext = context,
ProblemDetails =
{
Title = details.Title,
Detail = details.Detail,
Type = details.Type,
Status = details.StatusCode
}
});
}
}
});
});
Want to learn about the latest and greatest in the 64-bit Visual Studio 2022? Join Scott Hanselman and Visual Studio product team as they take Visual Studio 2022 for a spin.
20:27 Profiling .NET apps in Visual Studio 2022
23:19 Cross platform apps with WSL and CMake in Visual Studio 2022
26:07 Testing your .NET app on Linux
28:00 Easily create CI/CD pipelines using GitHub actions with Visual Studio 2022
30:40 Balloon drop!
In this part, we provide a list of VPS providers that you can use it to buy a vps.
We do not include cheap VPS with less than 0.5GB RAM and less than 12 months in this list. The price in this list is the average of 12 month. In addition, we don't include a VPS provider here, if the price is higher than well known providers such as Hetzner, Ovh, DigitalOcean, AWS, Azure.
Since we shipped .NET Standard 2.0 about a year ago, we’ve shipped two updates to .NET Core 2.1 and are about to release .NET Core 2.2. It’s time to update the standard to include some of the new concepts as well as a number of small improvements
Preview 3 of .NET 8 includes a new project templates to create an API with a TODO service instead of the weather forecast . Looking into the generated code of this template, there are a lot more changes going on such as a slim builder and using a JSON source generator which helps when using AOT to create native .NET binaries. This article looks into the changes coming.
