Blog

  • Perform CRUD operations with EF Core

    After EF Core is configured, you can use it to perform CRUD operations on your entity classes. Then, you can develop against C# classes, delegating the database operations to the context class. Database providers in turn translate it to database-specific query language. An example is SQL for a relational database. Queries are always executed against the database, even if the entities returned in the result already exist in the context.

    Query data

    The context object exposes a collection class for each entity type. In the preceding example, the context class exposes a collection of Pizza objects as Pizzas. Given that we have an instance of the context class, you can query the database for all pizzas:

    C#Copy

    var pizzas = await db.Pizzas.ToListAsync();
    

    Insert data

    You can use the same context object to insert a new pizza:

    C#Copy

    await db.pizzas.AddAsync(
        new Pizza { ID = 1, Name = "Pepperoni", Description = "The classic pepperoni pizza" });
    

    Delete data

    Delete operations are simple. They require only an ID of the item to be deleted:

    C#Copy

    var pizza = await db.pizzas.FindAsync(id);
    if (pizza is null)
    {
        //Handle error
    }
    db.pizzas.Remove(pizza);
    

    Update data

    Similarly, you can update an existing pizza:

    C#Copy

    int id = 1;
    var updatepizza = new Pizza { Name = "Pineapple", Description = "Ummmm?" };
    var pizza = await db.pizzas.FindAsync(id);
    if (pizza is null)
    {
        //Handle error
    }
    pizza.Description = updatepizza.Description;
    pizza.Name = updatepizza.Name;
    await db.SaveChangesAsync();
    nutanix certification malaysia
  • What is Entity Framework Core?

    Most nontrivial web applications need to reliably run operations on data, such as create, read, update, and delete (CRUD). They also need to persist any changes made by these operations between application restarts. Although there are various options for persisting data in .NET applications, Entity Framework (EF) Core is a user-friendly solution and a great fit for many .NET applications.

    Understand EF Core

    EF Core is a lightweight, extensible, open source, and cross-platform data access technology for .NET applications.

    EF Core can serve as an object-relational mapper, which:

    • Enables .NET developers to work with a database by using .NET objects.
    • Eliminates the need for most of the data-access code that typically needs to be written.

    EF Core supports a large number of popular databases, including SQLite, MySQL, PostgreSQL, Oracle, and Microsoft SQL Server.

    The model

    With EF Core, data access is performed by using a model. A model is made up of entity classes and a context object that represents a session with the database. The context object allows querying and saving data.

    The entity class

    In this scenario, you’re implementing a pizza store management API, so you use a Pizza entity class. The pizzas in your store have a name and a description. They also need an ID to allow the API and database to identify them. The Pizza entity class that you use in your application identifies pizzas:

    C#Copy

    namespace PizzaStore.Models 
    {
      public class Pizza
      {
          public int Id { get; set; }
          public string? Name { get; set; }
          public string? Description { get; set; }
      }
    }
    
    about

  • Publish .NET apps

    Coding an app with ASP.NET Core is different from designing a static website with HTML, CSS, and JavaScript. A static website can be deployed to any web server that supports static files. The web server doesn’t need to process static files; it simply serves them over HTTP. When a web browser requests a resource, the web server simply sends the file back to the browser.

    An ASP.NET Core app, on the other hand, is a dynamic web application. It runs as a program on the web server. When the user’s web browser sends a request to the web server, the web server runs the app to generate a response, and then the web server sends the response back to the browser.

    Publishing a .NET app is the process of preparing the app for deployment on a server. When you publish a .NET app, you package your app and its dependencies into a folder that can be easily deployed. The published app doesn’t include any source code files, but it does include all the files needed to run the app, including the compiled assemblies (DLLs), configuration files, and any other assets your app needs. The app can then be deployed to a web server, cloud service, or other hosting environment.

    Types of deployments

    When you publish a .NET app, you can choose between two different types of deployments: framework-dependent and self-contained. The type of deployment you choose affects how your app is packaged and deployed.

    affiliation
  • Discover Razor syntax

    Razor is a markup syntax for embedding .NET based code into webpages. The Razor syntax consists of Razor markup, C#, and HTML. Razor syntax is similar to the templating engines of various JavaScript single-page application (SPA) frameworks, such as Angular, React, VueJs, and Svelte.

    The default Razor language is HTML. Rendering HTML from Razor markup is no different than rendering HTML from an HTML file. The server renders HTML markup in .cshtml Razor files unchanged.

    Razor syntax

    Razor supports C# and uses the @ symbol to transition from HTML to C#. Razor evaluates C# expressions and renders them in the HTML output.

    When an @ symbol is followed by a Razor reserved keyword, it transitions into Razor-specific markup. Otherwise, it transitions into plain HTML. To escape an @ symbol in Razor markup, use a second @ symbol. The following code sample would render the value of @Username in the HTML output.Expand table

    SyntaxOutput
    <p>@Username</p>Renders the value of @Username in the HTML output.
    <p>@@Username</p>Renders “@Username” in the HTML output.

    HTML attributes and content containing email addresses don’t treat the @ symbol as a transition character. For example, the email addresses in the following code are untouched by Razor parsing:

    HTMLCopy

    <a href="mailto:Support@contoso.com">Support@contoso.com</a>
    

    Add code to a page using the @ character

    The following code examples show how the @ character can be used to implement inline expressions, single statement blocks, and multi-statement blocks:

    HTMLCopy

    <!-- Single statement blocks  -->
    @{ var myMessage = "Hello World"; }
    
    <!-- Inline expressions -->
    <p>The value of myMessage is: @myMessage</p>
    
    <!-- Multi-statement block -->
    @{
        var greeting = "Welcome to our site!";
        var weekDay = DateTime.Now.DayOfWeek;
        var greetingMessage = greeting + " Today is: " + weekDay;
    }
    <p>The greeting is: @greetingMessage</p>
    rooms

  • Perform HTTP operations in Blazor Web apps

    In this unit, you learn how to use the IHttpClientFactory to handle the HTTP client creation and disposal, and to use that client to perform REST operations in an ASP.NET Blazor Web app. The code samples used throughout this unit are based on interacting with an API that enables managing a list of fruit stored in a database. The information in this unit is based on using code-behind files in a Razor app.

    The following code represents the data model that is referenced in the code examples:

    C#Copy

    public class FruitModel
    {
        // An id assigned by the database
        public int id { get; set; }
        // The name of the fruit
        public string? name { get; set; }
        // A boolean to indicate if the fruit is in stock
        public bool instock { get; set; }
    }
    

    Register IHttpClientFactory in your app

    To add IHttpClientFactory to your app, register AddHttpClient in the Program.cs file. The following code example uses the named client type and sets the base address of the API used in REST operations, and is referenced throughout the rest of this unit.

    C#Copy

    // Add services to the container.
    builder.Services.AddRazorComponents()
        .AddInteractiveServerComponents();
    
    // Add IHttpClientFactory to the container and set the name of the factory
    // to "FruitAPI". The base address for API requests is also set.
    builder.Services.AddHttpClient("FruitAPI", httpClient =>
    {
        httpClient.BaseAddress = new Uri("http://localhost:5050/");
    });
    
    var app = builder.Build();
    careers

  • Service lifetimes

    When you register a service, you must choose a lifetime that matches how the service is used in the app. The lifetime affects how the service behaves when it’s injected into components. So far, you’ve registered services using the AddSingleton method. This method registers a service with a singleton lifetime. There are three built-in lifetimes for services in ASP.NET Core:

    • Singleton
    • Scoped
    • Transient

    Singleton lifetime

    Services registered with a singleton lifetime are created once when the app starts and are reused for the lifetime of the app. This lifetime is useful for services that are expensive to create or that don’t change often. For example, a service that reads configuration settings from a file can be registered as a singleton.

    Use the AddSingleton method to add a singleton service to the service container.

    Scoped lifetime

    Services registered with a scoped lifetime are created once per configured scope, which ASP.NET Core sets up for each request. A scoped service in ASP.NET Core is typically created when a request is received and disposed of when the request is completed. This lifetime is useful for services that access request-specific data. For example, a service that fetches a customer’s data from a database can be registered as a scoped service.

    Use the AddScoped method to add a scoped service to the service container.

    Transient lifetime

    Services registered with a transient lifetime are created each time they’re requested. This lifetime is useful for lightweight, stateless services. For example, a service that performs a specialized calculation can be registered as a transient service.

    Use the AddTransient method to add a transient service to the service container.

    g add

  • Interfaces and dependency injection

    To avoid dependencies on a specific service implementation, you can instead configure a service for a specific interface and then depend just on the interface. This approach gives you the flexibility to swap out the service implementation, which makes the code more testable and easier to maintain.

    Consider an interface for the PersonService class:

    C#Copy

    public interface IPersonService
    {
        string GetPersonName();
    }
    

    This interface defines the single method, GetPersonName, that returns a string. This PersonService class implements the IPersonService interface:

    C#Copy

    internal sealed class PersonService : IPersonService
    {
        public string GetPersonName()
        {
            return "John Doe";
        }
    }
    

    Instead of registering the PersonService class directly, you can register it as an implementation of the IPersonService interface:

    C#Copy

    var builder = WebApplication.CreateBuilder(args);
        
    builder.Services.AddSingleton<IPersonService, PersonService>();
    var app = builder.Build();
    
    app.MapGet("/", 
        (IPersonService personService) => 
        {
            return $"Hello, {personService.GetPersonName()}!";
        }
    );
        
    app.Run();
    contact

  • Understand dependency injection

    ASP.NET Core apps often need to access the same services across multiple components. For example, several components might need to access a service that fetches data from a database. ASP.NET Core uses a built-in dependency injection (DI) container to manage the services that an app uses.

    Dependency injection and Inversion of Control (IoC)

    The dependency injection pattern is a form of Inversion of Control (IoC). In the dependency injection pattern, a component receives its dependencies from external sources rather than creating them itself. This pattern decouples the code from the dependency, which makes code easier to test and maintain.

    Consider the following Program.cs file:

    C#Copy

    using Microsoft.AspNetCore.Builder;
    using Microsoft.AspNetCore.Http;
    using Microsoft.Extensions.DependencyInjection;
    using MyApp.Services;
    
    var builder = WebApplication.CreateBuilder(args);
        
    builder.Services.AddSingleton<PersonService>();
    var app = builder.Build();
    
    app.MapGet("/", 
        (PersonService personService) => 
        {
            return $"Hello, {personService.GetPersonName()}!";
        }
    );
        
    app.Run();
    

    And the following PersonService.cs file:

    C#Copy

    namespace MyApp.Services;
    
    public class PersonService
    {
        public string GetPersonName()
        {
            return "John Doe";
        }
    }
    

    To understand the code, start with the highlighted app.MapGet code. This code maps HTTP GET requests for the root URL (/) to a delegate that returns a greeting message. The delegate’s signature defines an PersonService parameter named personService. When the app runs and a client requests the root URL, the code inside the delegate depends on the PersonService service to get some text to include in the greeting message.

    Where does the delegate get the PersonService service? It’s implicitly provided by the service container. The highlighted builder.Services.AddSingleton<PersonService>() line tells the service container to create a new instance of the PersonService class when the app starts, and to provide that instance to any component that needs it.

    Any component that needs the PersonService service can declare a parameter of type PersonService in its delegate signature. The service container will automatically provide an instance of the PersonService class when the component is created. The delegate doesn’t create the PersonService instance itself, it just uses the instance that the service container provides.

    https://lernix.com.my/g-add-m
  • Retrieve application log files

    Log files are a great resource for a Web developer, but only if you know how to find and use the logged information. Here, you look at the methods you can use to retrieve logged information for offline analysis.

    Log file storage locations

    The Azure infrastructure used to run Azure Web Apps in Windows isn’t the same as for Linux apps, and log files aren’t stored in the same locations.

    Windows app log files

    For Windows apps, file system log files are stored in a virtual drive that is associated with your Web App. This drive is addressable as D:\Home, and includes a LogFiles folder; within this folder are one or more subfolders:

    • Application – Contains application-generated messages, if File System application logging is enabled.
    • DetailedErrors – Contains detailed Web server error logs, if Detailed error messages are enabled.
    • http – Contains IIS-level logs, if Web server logging is enabled.
    • W3SVC<number> – Contains details of all failed http requests, if Failed request tracing is enabled.

    Where storage to a Blob container is enabled, logs are stored in year, month, date, and hour folders, for example:Copy

    2019
      01
       10
        08 - log entries for the period 08:00:00 to 08:59:59 on January 10th 2019
        09 - log entries for the period 09:00:00 to 09:59:59 on January 10th 2019
    

    Within the hour folder, there are one or more CSV files containing messages saved within that 60-minute period.

    Linux app log files

    For Linux Web Apps, the Azure tools currently support fewer logging options than for Windows apps. Redirections to STDERR and STDOUT are managed through the underlying Docker container that runs the app, and these messages are stored in Docker log files. To see messages logged by underlying processes, such as Apache, you need to open an SSH connection to the Docker container.

    Methods for retrieving log files

    How you retrieve log files depends on the type of log file, and on your preferred environment. For file system logs, you can use the Azure CLI or the Kudu console. Kudu is the engine behind many features in Azure App Service related to source control based deployment.

    php and mysql training courses malaysia
  • View live application logging with the log streaming service

    In this unit, you look at how to view a live app log stream, and how live log streams can help during Web app development.

    What is live log streaming?

    Live log streaming is an easy and efficient way to view live logs for troubleshooting purposes. Live log streaming provides a quick view of all the messages sent to the app logs in the file system, without having to go through the process of locating and opening the logs. To use live logging, you connect to the live log service from the command line, and you can then see text being written to the app’s logs in real time.

    What logs can be streamed?

    The log streaming service adds a redirect from the file system logs, so that you see the same information that is saved to the log files. So, if you enable verbose logging for ASP.NET Windows apps, for example, the live log stream shows all your logged messages.

    Screenshot of Azure portal live log stream pane showing output from the asp logs container.

    Typical scenarios for using live logging

    Live logging is a useful tool for initial debugging. Real time log messages give you immediate feedback for code or server issues. You can then make a change, redeploy your app, and instantly see the results.

    The live log stream connects to a single app instance, so it’s not useful if you have a multi-instance app. Live logging is also of limited use as you scale up your apps. In these scenarios, it’s better to ensure that messages are saved to log files that can be opened and studied offline.

    red hat openstack training courses malaysia