useContext
is a React Hook that lets you read and subscribe to context from your component. React Context is a way to manage state globally.
The useNavigate
hook from React Router returns a function that lets you navigate programmatically, for example in an effect:
import { useNavigate } from "react-router-dom";
function useLogoutTimer() {
const userIsInactive = useFakeInactiveUser();
const navigate = useNavigate();
useEffect(() => {
if (userIsInactive) {
fake.logout();
navigate("/session-timed-out");
}
}, [userIsInactive]);
}
Button click
import { useNavigate } from 'react-router-dom';
...
const navigate = useNavigate();
...
<Button onClick={() => navigate('../user', { replace: true })}>Register</Button>
Reference
To only update one field, we can simply change the update method to the following:
Person person = new Person {Id=4, Lastname="Miller"};
dbContext.Attach(person);
dbContext.Entry(person).Property(p => p.Lastname).IsModified = true;
dbContext.SaveChanges();
The above function first constructs the object with the specified Id
and updated Lastname
, and then appends the object; it then explicitly marks the Lastname
property as modified.
The generated UPDATE statement now looks like this
info: Microsoft.EntityFrameworkCore.Database.Command[20101]
Executed DbCommand (8ms) [Parameters=[@p1='?' (DbType = Int32), @p0='?' (Size = 4000)], CommandType='Text', CommandTimeout='30']
UPDATE `Persons` SET `Lastname` = @p0
WHERE `Id` = @p1;
SELECT ROW_COUNT();
As shown in the EFCore log, only the Lastname
field is updated.
This approach can slightly improve performance because the SQL statement is smaller and the query execution on the database server can be faster.
See also the discussion at Stack Overflow How to update not every fields of an object using Entity Framework and EntityState.Modified
Logging is an essential part of application development for debugging, monitoring, and understanding the flow of execution, especially in complex systems. When logging in a C# method with parameters that need validation, it's crucial to follow best practices to ensure clear and useful log messages. Below is a sample demonstrating how to log and validate parameters in a C# method:
public bool ValidateAndProcessData(string data)
{
// Log the start of the method
_logger.LogInformation("ValidateAndProcessData method started");
// Validate input data
if (string.IsNullOrEmpty(data))
{
_logger.LogError("Input data is null or empty");
throw new ArgumentException("Input data cannot be null or empty", nameof(data));
}
try
{
// Process data
_logger.LogInformation("Processing data: {data}", data);
// Simulating processing time
System.Threading.Thread.Sleep(1000);
_logger.LogInformation("Data processed successfully");
return true;
}
catch (Exception ex)
{
// Log any exceptions that occur during processing
_logger.LogError(ex, "Error processing data: {data}", data);
throw; // Re-throw the exception for higher-level handling
}
finally
{
// Log the end of the method
_logger.LogInformation("ValidateAndProcessData method completed");
}
}
By following this sample, you ensure that your method logs relevant information about parameter validation and method execution, making it easier to debug and monitor your application's behavior.
C# is a strongly-typed language. It means we must declare the type of a variable that indicates the kind of values it is going to store, such as integer, float, decimal, text,
Additional reading at Data types in C# (tutorialsteacher.com)
C# includes specialized classes that store series of values or objects are called collections.
There are two types of collections available in C#: non-generic collections and generic collections.
The System.Collections
namespace contains the non-generic collection types and System.Collections.Generic
namespace includes generic collection types.
Additional reading at C# Generic & Non-generic Collections (tutorialsteacher.com)
In C#, a string is a series of characters that is used to represent text. It can be a character, a word or a long passage surrounded with the double quotes ". The following are string literals.
// String Literal Examples
"S"
"String"
"This is a string."
In a console apps, there is often a need to obtain user input from the console while ensuring that the input is not empty or only whitespace characters.
In this sample, we define a method GetUserInput
that takes an optional message parameter. It continuously prompts the user until a non-empty, non-whitespace input is provided.
static string GetUserInput(string message = "Please enter some input:")
{
string input;
do
{
Console.WriteLine(message);
input = Console.ReadLine()?.Trim();
} while (string.IsNullOrWhiteSpace(input));
return input;
}
Explanation:
message
parameter allows customizing input prompt message.Console.ReadLine()?.Trim()
reads user input and trims leading/trailing whitespace.?.
operator is used for null-conditional access, ensuring that Console.ReadLine()
doesn't throw a null reference exception if the input is null.do-while
loop ensures user input is not empty or whitespace.To filter out nullable strings and obtain only non-null strings, you can use LINQ Where
method along with a null check. Here's an example:
IEnumerable<string?> nullableStrings //
List<string> nonNullStringsList = nullableStrings
.Where(s => s != null) // Filter out null values
.Select(s => s!) // Convert nullable strings to non-nullable
.ToList(); // Convert IEnumerable to List
Where
to filter out null values and Select
to convert nullable strings to non-nullable strings (string!
indicates a non-nullable reference type in C# 8.0 and later).ToList()
to convert the filtered enumerable to a List<string>
.The JsonSerializer.Serialize
converts the value of a specified type into a JSON string.
using System.Text.Json;
var user = new User("Krish Jackon", "female", new MyDate(1985, 03, 30));
var json = JsonSerializer.Serialize(user);
Console.WriteLine(json);
The JsonSerializer.Deserialize
parses the text representing a single JSON value into an instance of a specified type.
using System.Text.Json;
string json = @"{""Name"":""Krish Jackon"", ""Gender"":""female"",
""DateOfBirth"":{""year"":1985,""month"":03,""day"":30}}";
var user = JsonSerializer.Deserialize<User>(json);
Resources to deserialize to dynamic object
In EF Core, joining a subquery with two columns (INNER JOIN table) can be achieved using LINQ syntax. Below is an example of how to do this:
var query = from user in context.Users
join post in context.Posts
on new { UserId = user.Id, IsPublished = true }
equals new { post.UserId, IsPublished = true }
select new
{
user.Username,
post.Title
};
In this example
Users
and Posts
tables on two columns (UserId
and a condition IsPublished
) using the equals
keyword.UserId = user.Id
, you are matching the UserId
column from the Post
entity with the Id
column from the User
entity.Additional reading at EF Core Join Query - TekTutorialsHub
To join a subquery (INNER JOIN table) in EF Core, you can use the Join
method along with LINQ expressions. Below is a example code snippet:
var query = from order in context.Orders
join orderItem in context.OrderItems
on order.OrderId equals orderItem.OrderId
where order.CustomerName == "John Doe"
select new
{
order.OrderId,
order.CustomerName,
orderItem.ProductName,
orderItem.Price
};
The expression on order.OrderId equals orderItem.OrderId
is used to specify the join condition between two tables/entities (Orders
and OrderItems
based on their related columns OrderId
.
Additional Reading at EF Core Inner Join (csharptutorial.net)
This code sample show how to insert an entity Element
without updating related entities.
_dbContext.Entry<Element>(element).State = EntityState.Added;
// Set the state of the Category navigation property of 'element' to Unchanged
_dbContext.Entry<Category>(element.Category).State = EntityState.Unchanged;
// Detach all roles associated with the 'element' from the DbContext
element.Roles.ToList().ForEach(r => _dbContext.Entry<Role>(r).State = EntityState.Detached);
// Mark the Roles collection of 'element' as not modified to prevent updating roles
_dbContext.Entry<Element>(element).Collection(r => r.Roles).IsModified = false;
await _dbContext.SaveChangesAsync();
element
's associated Category
object to Unchanged in the _dbContext
. This indicates that the Category
object is not modified and should not be updated in the database.Role
, it sets the state to Detached
. Detaching an entity means it is no longer tracked by the EF Core context for changes.IsModified
property of the Roles
collection in the element
is explicitly set to false
. This indicates to EF Core that the Roles
collection has not been modified and should not be updated in the database.To inspect the SQL generated by your LINQ query, you can convert the LINQ query to a SQL string using the ToQueryString()
method.
// Example LINQ query
var query = from o in context.Orders;
// Convert LINQ query to SQL string
string sqlQuery = query.ToQueryString();
Console.WriteLine(sqlQuery);
This code snippet demonstrates how to generate and inspect the SQL query string using LINQ in C# useful for debugging and optimization purposes.
The provided code snippet demonstrates a LINQ query to group by multiple columns while also finding the maximum item ID within each group. Here's a breakdown of the code:
var result = from o in context.Orders
group o by new { o.CustomerId, o.OrderType } into g
select new
{
CustomerId = g.Key.CustomerId,
OrderType = g.Key.OrderType,
MaxItemId = g.Max(x => x.ItemId)
};
In this code:
group by new { o.CustomerId, o.OrderType }
syntax allows grouping by a combination of CustomerId and OrderType using an anonymous typeinto g
clause signifies that the grouped data will be accessible through the identifier g
g.Key
property allows access to the grouped key values, such as CustomerId and OrderType.select new { ... }
creates a new anonymous object for each group containing CustomerId, OrderType, and the maximum ItemId
Max()
method is used to find the maximum ItemId within each group (g.Max(x => x.ItemId)
)This code efficiently retrieves the maximum ItemId
for each unique combination of CustomerId
and OrderType
in the orders collection.
To group in EF Core using LINQ query syntax, use the group by
clause followed by the grouping key and aggregate functions as needed. For example, to group a collection of items by a property called "Category" and count the items in each group:
var groupedData = from item in dbContext.Items
group item by item.Category into grouped
select new { Category = grouped.Key, Count = grouped.Count() };
In PowerShell, you can show elapsed time using a simple timer script. Start by capturing the current time when your script begins with $StartTime = $(Get-Date)
. Then, calculate the elapsed time by subtracting the start time from the current time: $elapsedTime = $(Get-Date) - $StartTime
. Format the elapsed time into hours, minutes, and seconds using the "{0:HH:mm:ss}"
format and apply it to a DateTime object: $totalTime = "{0:HH:mm:ss}" -f ([datetime]$elapsedTime.Ticks)
.
$StartTime = $(Get-Date)
# Your script here
$elapsedTime = $(Get-Date) - $StartTime
$totalTime = "{0:HH:mm:ss}" -f ([datetime]$elapsedTime.Ticks)
Write-Host "Total elapsed time: $totalTime"
For more details and discussions, you can refer to this Stack Overflow post.
The Invoke-WebRequest
PowerShell cmdlet is used to fetch content from a web page on the internet. It allows you to make HTTP requests, retrieve HTML content, and interact with web APIs directly from your PowerShell script.
Gets content from a web page on the internet.
# Here we are asking Google about PowerShell and saving the response
$Response = Invoke-WebRequest -URI https://www.google.com/search?q=powershell
# We use the Content property of $Response to access the webpage content
$Response.Content
In the example above, $Response
will store the content retrieved from the specified URL (https://www.google.com/search?q=powershell
). You can then use $Response
to parse and extract information from the web page as needed.
To learn more about Invoke-WebRequest
, you can visit the Microsoft documentation page. This resource provides detailed information and examples to help you understand and use this cmdlet effectively.