OneAnanda

Handling Multiple Value Returns in C#: Techniques and Best Practices

noreply@blogger.com (One-Ananda) — Sat, 29 Mar 2025 03:58:00 +0000

Handling Multiple Value Returns in C#: Techniques and Best Practices

When coding in C#, you might run into situations where you need your methods to return more than just one value. Instead of juggling multiple lines of code to send back a bunch of data, C# offers several neat ways to do it. Let’s walk through some of these techniques using a simple example: calculating the double and triple of a number.

1. Out Parameters

Think of out parameters as a way to send back extra data without having to create a whole new object. With out parameters, you can pass variables into a method, and then the method fills them in for you. Here’s a quick look:

public static void GetDataViaOut(int input, out int doubled, out int tripled)
{
    doubled = input * 2;
    tripled = input * 3;
}

Pros:

Simple and straightforward for small tasks.
Works with any version of C#.

Cons:

Can be confusing if you have too many out parameters.
Not always the clearest way to show what your method does.

2. Tuples

Tuples are a modern and concise way to return multiple values, introduced in C# 7.0. They let you name the values you’re returning, which makes your code easier to read. Here’s how you might use them:

public static (int Doubled, int Tripled) GetDataViaTuple(int input)
{
    return (input * 2, input * 3);
}

You can grab the values like this:

var result = GetDataViaTuple(5);
Console.WriteLine($"Doubled: {result.Doubled}, Tripled: {result.Tripled}");

var (doubled, tripled) = GetDataViaTuple(5);
Console.WriteLine($"Doubled: {doubled}, Tripled: {tripled}");

Why I like tuples:

They make your intentions clear with named values.
Less code is often needed compared to out parameters.

3. Custom Classes or Structs

Sometimes you’re working with related data, and it makes sense to group it together in a custom class or struct. This way, you’re not just returning raw numbers, but a meaningful object. For example:

public class DataResult
{
    public int Doubled { get; set; }
    public int Tripled { get; set; }
}

public static DataResult GetDataViaCustom(int input)
{
    return new DataResult { Doubled = input * 2, Tripled = input * 3 };
}

Benefits:

It clearly shows that the values belong together.
Easy to extend if you need to return more related data later.

Drawback:

Might feel like too much work for simple tasks.

4. KeyValuePair

If you only need to return two values, you might consider using a KeyValuePair. It’s quick and gets the job done:

public static KeyValuePair<int, int> GetDataViaPair(int input)
{
    return new KeyValuePair<int, int>(input * 2, input * 3);
}

Highlights:

Simple and direct when working with just two values.

Limitations:

The property names Key and Value aren’t very descriptive unless you’re used to them.

5. Arrays and Collections

When you’re returning values of the same type or a variable number of items, an array or a collection like a List might be the way to go. For instance:

public static int[] GetDataViaArray(int input)
{
    return new int[] { input * 2, input * 3 };
}

Or, if you want to update an existing collection:

public static void GetDataViaCollectionReference(int input, int[] initialized)
{
    initialized[0] = input * 2;
    initialized[1] = input * 3;
}

Pros:

Flexible when dealing with a list of values.

Cons:

The meaning of each position in the array isn’t obvious unless you document it well.

Wrapping It Up

Choosing the right approach depends on your specific needs.

Out parameters and KeyValuePair are great for quick, simple returns.
Tuples and custom classes/structs shine when you need clarity and readability.
Arrays and collections are your go-to when dealing with multiple values of the same type or when the number of returned items can vary.

By understanding these methods, you can pick the one that fits your coding style and project needs best. Enjoy experimenting with these techniques and making your C# code cleaner and more efficient!

The complete source code is available here

Happy coding!

Amazon Inspector

noreply@blogger.com (One-Ananda) — Mon, 30 Sep 2024 01:21:00 +0000

Amazon Inspector is an automated security assessment tool focused on identifying vulnerabilities and scans security best practices in AWS.

Amazon Inspector specifically works with EC2, Containers and Lamba (indirectly).

Amazon Inspector is like a security expert who regularly checks the cloud servers and container images for weak spots. If it finds any potential issues, like an old piece of software that hackers could exploit, it lets us know and guides us on how to fix it. It’s an automated security checkup that keeps the cloud environment safe and up to date.

In short, Amazon Inspector helps to identify security risks in AWS servers and containers so that we can fix them quickly and keep the applications safe.

Use Cases:
- Detecting security vulnerabilities in EC2 instances, such as unpatched software or network misconfigurations.
- Assessing container images in ECR for potential security issues.
- Continuous security monitoring in DevOps pipelines.

Amazon Inspector works specifically with certain AWS services, focusing on assessing security vulnerabilities and compliance for workloads running in those services.

Here’s a table of where Amazon Inspector can and cannot operate in terms of AWS services:

Summary of Supported and Unsupported Services:

Service	Amazon Inspector Support
Amazon EC2	✔️ Supported
Amazon ECR	✔️ Supported
Amazon Lambda (container-based)**	Limited (via ECR image scanning)
Amazon S3	❌ Not Supported
Amazon RDS	❌ Not Supported
Amazon DynamoDB	❌ Not Supported
Amazon IAM	❌ Not Supported
Amazon SQS/SNS	❌ Not Supported
AWS Networking (VPC, Route 53)	❌ Not Supported
Amazon CloudFront, API Gateway	❌ Not Supported

Amazon Inspector focuses on Amazon EC2 instances and Amazon ECR for container image security. For other AWS services like databases, storage, and identity management, you will need to use complementary AWS security services such as Amazon Macie, AWS Security Hub, AWS IAM Access Analyzer, and others to cover those areas.

Hot Partition in DynamoDB

noreply@blogger.com (One-Ananda) — Mon, 23 Sep 2024 15:02:00 +0000

A hot partition in DynamoDB occurs when one or more partitions receive a disproportionately high amount of traffic, while other partitions remain underutilized. This imbalance can happen if the partition key used to distribute data doesn't have enough distinct values, leading to concentrated read or write activity on a small subset of partitions.

Let’s consider a real-world example to explain hot partitions in DynamoDB and how to avoid them.

Scenario:

You are building an online shopping website, and you want to store customer orders in a DynamoDB table. Let’s say you define the table with the following schema:

Partition key: CustomerID (The unique ID of the customer)
Sort key: OrderID (The unique ID of the order placed by the customer)

Problem:

If you have a small number of high-volume customers (e.g., big corporate clients placing hundreds of orders daily) and many low-volume customers, you will have a hot partition problem. For example:

Customer A might place 500 orders every day.
Customer B might place 10 orders every day.
Other customers might place only a few orders every month.

In this case, DynamoDB will assign all the orders for each customer (based on CustomerID) to the same partition, resulting in high traffic on the partition for Customer A. This could overload that specific partition and cause performance issues, like throttling and delayed responses. Meanwhile, the partitions for low-traffic customers remain underutilized.

How to Avoid Hot Partitions:

High Cardinality Partition Key: Instead of just using CustomerID as the partition key, you can include an additional high-cardinality attribute, like OrderDate or OrderMonth. This spreads the data across more partitions.
New Partition Key: Combine CustomerID and OrderDate.
- Partition key: CustomerID#OrderDate
- Sort key: OrderID
Now, each day's orders for a given customer are spread across different partitions, avoiding hotspots for high-traffic customers.
Example of partition key values:
- CustomerA#2024-09-21
- CustomerA#2024-09-22
- CustomerB#2024-09-21
This ensures that the system doesn't overload a single partition based on customer activity alone.
Write Sharding: If the CustomerID is required to be the sole partition key, another approach is write sharding. In this case, you modify the partition key by adding a random suffix.
For instance, you could add a random number between 1 and 10 to the CustomerID to create multiple shards:
New Partition Key: CustomerID + RandomNumber
- Partition key: CustomerID#Shard1
- Sort key: OrderID
Example:
- For CustomerA, generate keys like CustomerA#1, CustomerA#2, etc.
- Orders will be distributed randomly across different shards, reducing the risk of hot partitions.

Summary:

In the original setup, CustomerID as the partition key can lead to hot partitions because high-traffic customers cause excessive load on certain partitions.
By adding high-cardinality attributes or using write sharding, you can distribute the workload evenly across DynamoDB partitions, avoiding hot partitions and improving performance.

AWS DDoS Protection Services

noreply@blogger.com (One-Ananda) — Tue, 17 Sep 2024 07:29:00 +0000

AWS DDoS Protection Services

Overview of AWS services that actively protect against SYN Flood attacks or divert requests to mitigate the impact of such attacks.

AWS Service	Protection Type	Active Protection	Divert Requests	Monitoring and Alerts
AWS Shield Standard	Automatic protection against common DDoS attacks, including SYN Floods	Yes	No	No
AWS Shield Advanced	Enhanced DDoS protection with detailed diagnostics and access to DRT	Yes	No	Yes
AWS WAF	Custom rules for blocking or rate-limiting traffic, primarily focused on Layer 7	Partial (primarily Layer 7)	No	Yes
Elastic Load Balancing (ELB)	Distributes traffic across multiple targets to absorb impact	Yes	No	Limited
AWS Global Accelerator	Diverts traffic through AWS global network for improved availability and performance	Yes	Yes	Yes
Amazon CloudFront	Caches content at edge locations and filters malicious requests	Yes	Yes	Yes
VPC Security Groups	Blocks suspicious traffic at the VPC level	Partial	No	No
Network ACLs	Adds an additional layer of protection by filtering traffic	Partial	No	No
AWS Firewall Manager	Centrally manages firewall rules across AWS services for consistent protection	Yes	No	Yes
AWS Route 53	Scalable DNS with built-in DDoS protection that diverts traffic	Yes	Yes	Limited

Key Points

Active Protection: Services that provide proactive measures to block or mitigate SYN Flood attacks.
Divert Requests: Services that can divert or route traffic to reduce the impact of attacks on your resources.
Monitoring and Alerts: Indicates whether the service offers monitoring and alert capabilities to track potential threats and respond accordingly.

SYN Flood Attack

noreply@blogger.com (One-Ananda) — Sat, 14 Sep 2024 18:19:00 +0000

SYN Flood Attack

A SYN flood is a type of Denial of Service (DoS) attack that targets the handshake process of the TCP/IP protocol used for establishing a connection between a client and a server.

A SYN flood attack is like someone repeatedly knocking on your door without any intention of entering, just to keep you busy and prevent you from attending to real visitors.

How SYN Flood Attacks Work

Normal TCP Handshake:
- Normally, when two computers want to talk to each other over the internet, they perform a "handshake," like a polite greeting:
  1. Step 1: The client sends a “Hello” (SYN packet) to the server.
  2. Step 2: The server responds with a “Hello back” (SYN-ACK packet).
  3. Step 3: The client replies with an “Okay, let’s talk” (ACK packet), and the connection is established.
SYN Flood:
- In a SYN flood, the attacker sends a lot of those initial “Hello” messages (SYN packets) but never replies to the server’s “Hello back” (SYN-ACK).
- The server keeps waiting for the final “Okay, let’s talk” (ACK) that never comes. It has to keep resources reserved for these half-open connections, which ends up using a lot of its capacity.
Why It’s a Problem:
- Wasted Resources: (Resource Exhaustion) The server gets bogged down with all these unfinished handshakes, using up memory and processing power.
- Unavailable Service: (Service Unavailability) Legitimate users who actually want to connect can’t get through because the server is too busy dealing with the fake requests.

How to Protect Against SYN Floods

SYN Cookies: Imagine checking the sincerity of every “Hello” before reserving time for a full conversation. This prevents your resources from being held hostage by fake handshakes.
Rate Limiting: This is like setting a rule that says, “Only a certain number of ‘Hellos’ per minute,” so you don’t get overwhelmed.
Firewalls and IPS: Think of these as security guards who can spot the fake handshakes and block them at the door.
Timeout Reduction: If a handshake doesn’t complete quickly, drop it and move on. It’s like hanging up on a prank call faster.
Load Balancing and Redundancy: Spread out the connections across multiple servers or have backups ready, so no single server gets overloaded.

Knowing about SYN floods is crucial for designing robust systems that can withstand malicious attempts to disrupt service availability.

AWS Security Services Overview - Exam twisting questions

noreply@blogger.com (One-Ananda) — Sat, 14 Sep 2024 17:34:00 +0000

AWS Security Services Overview

Scroll horizontal for see the Limitations, Exam Question Twists, Cost-Effectiveness, Ease of Integration

Service	Capabilities	Limitations	Exam Question Twists	Cost-Effectiveness	Ease of Integration
AWS WAF (Web Application Firewall)	Protects web applications from common attacks like SQL injection and XSS.	Only protects application layer; not effective for non-web or network-layer attacks.	Questions may ask about its use for network-level attacks, which it doesn't handle.	Moderate cost based on usage; costs can increase with traffic and rules.	Integrates easily with CloudFront, ALB, API Gateway; complex with custom rules.
AWS Shield	Provides DDoS protection; Advanced tier offers enhanced response and support.	Does not protect against application-layer attacks; focuses on DDoS mitigation.	Scenarios may confuse Shield Standard and Advanced benefits or suggest protection at the application layer.	Standard is free; Advanced has a subscription fee.	Easy integration for Standard; Advanced setup requires AWS Support involvement.
AWS IAM (Identity and Access Management)	Controls access to AWS services with fine-grained permissions.	Does not handle external identity federation; careful setup needed to avoid overly permissive access.	Twists could involve complex policy setups, roles vs. groups, or permission boundaries.	Free but time-intensive to manage policies; misconfigurations can lead to security risks.	Integrated with AWS; complex in environments with many policies/roles.
AWS KMS (Key Management Service)	Manages and controls encryption keys with AWS service integration.	Not as secure as hardware-based solutions; limited for some compliance needs.	Questions might twist with comparisons to CloudHSM or scenarios needing key rotation and cross-region management.	Cost-effective per key use; scales with usage but can be costly.	Seamless integration with AWS; more effort needed for hybrid environments.
AWS Secrets Manager	Manages secrets like API keys and rotates them automatically.	Does not protect other sensitive data directly; must be used alongside other security tools.	May ask to choose between Secrets Manager and Parameter Store or involve scenarios with automated rotations.	Higher cost than Parameter Store; charges per secret and API call.	Easy integration with AWS; external integrations may need extra setup.
AWS CloudHSM	Provides dedicated hardware for key management with high compliance.	High setup complexity and cost; manual integration needed for many AWS services.	Scenarios may test knowledge of high compliance needs or mislead on cost and integration ease compared to KMS.	Costly; charged per HSM instance.	Complex integration; best for specialized, high-compliance requirements.
Amazon GuardDuty	Monitors AWS environments for malicious activity and unauthorized behavior.	Detects threats but does not block or respond automatically.	Questions may twist by suggesting GuardDuty provides active blocking; understand it only detects and alerts.	Cost scales with the volume of data processed; pay-per-use model.	Easy AWS integration; outputs can feed into AWS Security Hub or third-party tools.
AWS Config	Monitors AWS resource configurations for compliance and security.	Does not automatically fix non-compliance; requires manual intervention or automation.	Twists may suggest auto-remediation capabilities, which Config doesn't provide directly.	Costs depend on rule evaluations; high-frequency evaluations can be expensive.	Good integration with AWS; remediation needs additional tools like Lambda.
AWS Artifact	Provides access to AWS compliance documents and security reports.	Does not enforce compliance; informational use only.	Questions might imply Artifact offers active compliance checks; focus on its documentation role.	Free service.	Simple to access; no integration needed.
AWS Inspector	Assesses EC2 instances for vulnerabilities and compliance issues.	Limited to specific instance types and OS; does not cover containers or serverless directly.	Scenarios may mislead by suggesting broader coverage; focus on its scope for EC2.	Charged per assessment; costs add up with frequent scans.	Easy with EC2; lacks direct support for containers/serverless.
AWS Certificate Manager (ACM)	Manages SSL/TLS certificates for AWS services.	Limited to AWS environments; cannot manage external service certificates directly.	Exam might suggest capabilities beyond AWS; know ACM's scope within AWS.	Free for public certificates; private certificates have additional costs.	Seamless with AWS services; limited external integration.
AWS Directory Service	Manages Microsoft Active Directory within AWS.	Limited to AD; doesn't support other identity systems like LDAP or Okta directly.	Questions may involve unsupported systems; focus on its AD-specific role.	Varies by directory type; enterprise setups can be costly.	Good with AWS; hybrid configurations add complexity.
AWS Firewall Manager	Centralizes firewall rule management across multiple AWS accounts.	Limited to AWS services it integrates with; cannot manage third-party firewalls.	Exam may twist by implying broader management scope; focus on its AWS-specific integrations.	Costs add on top of WAF/Shield; can get expensive at scale.	Easy within AWS; cannot manage non-AWS firewalls.
AWS Macie	Uses ML to identify and protect sensitive data in AWS.	Limited to AWS data; doesn't extend to on-premises or other clouds.	Questions might suggest it works beyond S3; focus on S3 and PII detection.	Pay-per-GB; costs rise with large data sets.	Simple with S3; lacks broad integration for other sources.
AWS CloudTrail	Tracks user activity and API usage for auditing and governance.	Does not prevent unauthorized access; logs must be monitored separately.	Scenarios may confuse logging with real-time monitoring; CloudTrail is audit-focused.	Free for management events; other logs have costs.	Native to AWS; integrates well with other analysis tools.
Amazon Detective	Analyzes AWS logs and data to identify security issues.	Investigative only; doesn't prevent or respond to incidents.	Twists might suggest mitigation capabilities; focus on analysis role.	Pay-per-use; costs scale with data volume.	Integrates well with GuardDuty and Security Hub; external logs need setup.
AWS Security Hub	Aggregates security alerts and compliance statuses across AWS.	Does not provide remediation; serves as a dashboard for alerts.	Questions may imply automatic fixes; know it aggregates alerts and integrates for overview.	Pay-per-finding; costs rise with more alerts and integrations.	Easy with AWS; setup needed for third-party tools.
AWS Network Firewall	Manages network security with firewall rules and intrusion prevention.	Limited to AWS VPCs; no support for on-premises or hybrid setups.	Questions may suggest broader use; focus on its VPC-specific role.	Costs depend on traffic processed; can be high with heavy use.	Easy within VPCs; lacks support for external environments.
AWS SSO (Single Sign-On)	Provides centralized access and SSO for AWS accounts and integrated apps.	Limited to supported AWS services and apps; not universal for all third-party apps.	Twists might suggest it replaces IAM; know its scope within AWS and supported apps.	Free for AWS apps; custom integrations may incur costs.	Easy for AWS; needs SAML or other configurations for third-party.
AWS Systems Manager Parameter Store	Securely stores configuration data and secrets, using AWS KMS encryption.	Basic storage without advanced secret management features like auto-rotation.	Questions may confuse it with Secrets Manager; differentiate by its simpler storage role.	Free for basic parameters; advanced parameters have costs.	Simple with AWS; not as robust for secret management as Secrets Manager.
AWS Detective	Provides insights into potential security issues using ML and analysis.	Detection only; no active threat mitigation or response.	Twists may involve scenarios suggesting active responses; focus on its analytical role.	Pay-per-use; scales with data complexity.	Integrates easily with Security Hub, GuardDuty; limited for non-AWS sources.
AWS Access Analyzer	Analyzes and identifies resources shared with external entities.	Only recommends changes; doesn't enforce access restrictions automatically.	Scenarios may twist by suggesting auto-enforcement; focus on its advisory role.	Free service.	Easy within AWS IAM; limited to AWS environments.
AWS Service Catalog	Manages approved IT services for compliance and policy adherence.	Doesn't monitor ongoing compliance; limited to service catalog management.	Questions may mislead by suggesting it handles active compliance checks.	Pay-per-use; cost varies by catalog size and usage.	Good integration with AWS; governance setup can be complex.
AWS Organizations	Centralized management of AWS accounts with security and compliance policies.	Limited to AWS; can't manage non-AWS accounts.	Exam scenarios might suggest cross-cloud management; focus on AWS-specific policies and account structures.	Free; some paid features like advanced policies and consolidated billing.	Easy within AWS; lacks support for non-AWS environments.
AWS Resource Access Manager (RAM)	Simplifies sharing AWS resources across accounts without shared credentials.	Limited to sharing; doesn't manage detailed permissions beyond AWS resources.	Questions may twist by implying it handles detailed permissions; focus on its sharing capabilities.	Free for most sharing scenarios.	Easy within AWS; limited to AWS resources.

AWS NAT Gateway vs. AWS NAT Instance

noreply@blogger.com (One-Ananda) — Thu, 12 Sep 2024 13:13:00 +0000

AWS NAT Gateway vs. AWS NAT Instance

Feature	NAT Gateway	NAT Instance
Management	Fully managed by AWS; no maintenance needed.	User-managed; requires manual setup and updates.
Scalability	Automatically scales up to handle high traffic (up to 45 Gbps).	Manual scaling; limited by EC2 instance type.
High Availability	Highly available within an Availability Zone; can be set up in multiple AZs for redundancy.	Can be made highly available, but requires custom setup (e.g., Auto Scaling).
Performance	Consistent and high performance for most workloads.	Performance depends on the chosen instance type; can vary.
Security	Does not allow inbound connections from the internet; only outbound.	Customizable security with security groups; can control inbound rules.
Setup and Ease of Use	Easy to set up with minimal configuration; integrates well with VPC.	More complex setup with configuration of EC2 instances and routing.
Cost	Charged per hour and per GB of data processed; generally more expensive for high usage.	Costs include EC2 instance charges, EBS, and data transfer; can be cheaper for low traffic.
Static IP	Automatically gets a public IP; can associate an Elastic IP for a fixed address.	Can be assigned an Elastic IP or use a public IP of the instance.
Monitoring	Integrated with CloudWatch for easy monitoring of metrics like data transfer and connections.	Requires manual setup for monitoring and logging.
Use Case	Best for those who want a "set it and forget it" solution with minimal overhead.	Ideal for custom setups, lower cost scenarios, or when specific configurations are needed.

Interface-Driven Development - IDD - Deep Dive

noreply@blogger.com (One-Ananda) — Sat, 07 Sep 2024 15:36:00 +0000

Interface-Driven Development - IDD

`Interface-Driven Development - IDD` is a Software development design approach that emphasis on using interfaces to define contracts or boundaries between different components of the system.

The principle is, the components should interact each other using well defined interfaces which leads to

Modularity
Flexiblity
Testablity
Maintainablity

Key Concepts

Interface as a contract

An interface defines a contract and the classes which implement those should comply with the same,

That means if an interface is having a method called Print() in C# like this

public interface IPrint
{
	void Print();
}

The implementing class should comply with the contract that it is implementing the method Print()

public class Process : IPrint
{
	public void Print()
	{
		// Print logic
	}
}

But there is a catch here:

IPrint is insisting the implementation should use the method Print() but in reality there is no necessity to implement the printing functionality inside the Print() function, we can choose to write any other logic inside the Print(), the interface has no control over this.

The Print() method in the Process class could include logic to print something to the console, save a file, or even do nothing at all. The implementation inside the Print() method is up to the developer.

This means that while the interface guarantees that the method Print() is available in the Process class, it doesn't ensure that the method performs any specific action related to printing. The method could theoretically do something entirely unrelated, like calculating a sum or logging data.

The interface only ensures the method signature (i.e., the name, return type, and parameters) but has no control over the actual code inside the method.

Decoupling

IDD encourages decoupling between components, Since components interact through interfaces, they don’t need to know about each other's concrete implementations. This reduces dependencies and allows for easier changes and maintenance.

But there is a catch here too

Using decoupling may lead to

Over-Decoupling

Over-decoupling can lead to a situation where the system becomes excessively fragmented. This means introducing too many layers or abstractions between components can make the system harder to understand and navigate. It can also introduce unnecessary complexity without significant benefits.

Scenario: Suppose you have a simple application that reads and writes user data to a database. To achieve maximum decoupling, you create separate classes and interfaces for every tiny aspect of the application: one class for data access, one for validation, one for transformation, and so on.

public interface IUserDataAccess
{
    void SaveUser(User user);
}

public class UserDataAccess : IUserDataAccess
{
    public void SaveUser(User user) { /* Save logic */ }
}

public interface IUserValidator
{
    bool Validate(User user);
}

public class UserValidator : IUserValidator
{
    public bool Validate(User user) { /* Validation logic */ }
}

Problem: Managing and understanding the interactions between these highly decoupled components can become cumbersome, especially for a small application where simpler designs might be more appropriate.

Interface Proliferation

Overusing interfaces can lead to a proliferation of small, fine-grained interfaces. This can make the system harder to manage and understand, and it may lead to a situation where you have many interfaces with single methods or tightly focused responsibilities.

Difficulty in Testing

While interfaces make mocking easier, they can also complicate testing if not used properly. For example, a test might need to deal with multiple interfaces and their implementations, increasing the setup complexity for unit tests.

Loss of Cohesion

Scenario: You have a class that initially managed user-related functionality, but you split it into several smaller classes, each handling a specific aspect (e.g., user creation, user update, user deletion), which leads to a greater confusion of original purpose.

public class UserCreationService
{
    public void CreateUser(User user) { /* Create logic */ }
}

public class UserUpdateService
{
    public void UpdateUser(User user) { /* Update logic */ }
}

public class UserDeletionService
{
    public void DeleteUser(User user) { /* Delete logic */ }
}

AWS Learning 001 - Amazon EC2 - 003 - Instance Purchase Options

noreply@blogger.com (One-Ananda) — Sat, 07 Sep 2024 15:11:00 +0000

Amazon EC2 Instance Purchase Options

Instance Purchasing Options in AWS EC2:

On-Demand Instances

Pay by hour / pay by seconds
No long term commitments
Charges only if the instance is running

Savings plan

Compute savings plan
- Provides most flexiblity
- Discounts apply across different
  - Instance types
  - Sizes
  - Regions
EC2 instance savings plan
- Offers the lowest prices
- Discounts apply to specific instance families in a choosen region

Reserved Instances (RI)

General characteristics for Reserved Instances

Commitment from 1 to 3 years
The following determine the price
- Instance type
- Region
- Platform
Can buy / sell the unused instances in AWS Marketplace, except for Convertible RIs

Standard Reserved Instances

Use Case: Steady-state, predictable workloads.
Economy: High savings with long-term commitment.

Convertible Reserved Instances

Use Case: Workloads that may change.
Economy: Moderate savings with long-term commitment.

Scheduled Reserved Instances

Use Case: Predictable workloads that run on schedule.
Economy: Cost savings compared to On-Demand, but with scheduled flexibility.

Spot Instances

Cost sensitive that can accept interuptions
Suitable for non-critical workloads
There is no commitment needed
Anytime the instance may get terminated

Dedicated Hosts

Dedicated hardware
Rent a host or rack
Suitable for the SW which you pay per socket, pay per core, pay per VM licences to reduce costs
Supports BYOL (Bring your own licence)

Dedicated hosts are particularly used when you have a dedicated SW which is tied to specific physical metrices such as,

Number of core
Sockets
Virtual Machines

These Software often desingnated to run on specifcic Hardware

Example: SQL Server Licencing

Suppose you have a SQL Server license that is based on the number of physical cores on a server. The license states that you can run SQL Server on up to 8 physical cores per license.

Physical Core Visibility: A Dedicated Host gives you visibility into the physical server's configuration. For instance, you might choose a Dedicated Host with exactly 8 cores to fully utilize your SQL Server license.
Compliance: Since you're aware of and can control the number of cores, you can ensure that your SQL Server instance is compliant with the licensing terms. You can place one or more instances of SQL Server on this Dedicated Host, knowing that you're not exceeding the licensed core count.
Host Affinity (Attachment): If your license requires that the software remains on specific hardware, you can use host affinity to ensure that your SQL Server instances always run on this Dedicated Host.

If you are not using Dedicated host for this scenario

No Physical Core Visibility: In a typical EC2 instance or even on a Dedicated Instance, you don’t have visibility or control over the underlying physical cores
Potential Non-Compliance: Without this visibility and control, it becomes challenging to ensure compliance with licensing terms that are tied to physical core counts

Dedicated Instances

Dedicated hardware
Similiar to Dedicated Hosts but having less control over the hardware
Less granular control
Supports partially BYOL (Bring your own licence)
Typically, Dedicated Instances are less expensive than Dedicated Hosts

Differences Between Dedicated Hosts and Dedicated Instances

Feature	Dedicated Hosts	Dedicated Instances
Control and Visibility	Provides control over the physical server, with visibility into sockets, cores, etc.	No visibility into the underlying host; AWS manages the server placement.
Licensing	Supports BYOL for licenses that require core, socket, or VM-level compliance.	Supports BYOL, but with less flexibility in managing hardware-bound licenses.
Host Affinity (Attachment)	Allows instance placement on specific Dedicated Hosts, enabling host affinity.	No control over instance placement; AWS handles it.
Compliance Requirements	Helps meet compliance by providing control over the physical environment.	Less suited for strict compliance needs due to lack of control over the physical host.
Instance Types	Allows mixing of different EC2 instance types within the same family on a single host.	Instances are managed by AWS with no control over instance type placement.
Management Complexity	Requires more management and monitoring due to increased control.	Simpler to manage, as AWS handles the underlying server management.
Cost	Potentially higher cost due to increased control and management.	Generally easier and potentially less expensive to manage, depending on use case.

Capacity Reservations

We can reserve Capacity Reservations for any Availablity Zone for any duration
No long term commitment is needed
This is ensuring capacity availability for mission-critical apps.

AWS Learning 001 - Amazon EC2 - 002 - Instance Types

noreply@blogger.com (One-Ananda) — Sat, 07 Sep 2024 07:10:00 +0000

Amazon EC2 Instance Types

`Amazon EC2 Instances` are categorized based on performance characteristics and appropriate use cases.
The following are the instance types `based on the performance`

EC2 Instance Types and Server Purposes - Use Cases

General Purpose

`Balances computing, memory and networking resources`
Suitable for variety of workloads
T-Family instances offer burstable performance by utilizing CPU credits
Once CPU credits exhausted then the bursting capabilities are disabled, until more credits are earned
Use Case Description
Web Servers Suitable for a balanced mix of compute, memory, and networking.
Application Servers Suitable for backend applications that handle non-heavy compute, memory, and networking.
Small to Medium Databases Applicable where computing and memory are not heavily used.
Development and Test Environments Suitable for balanced SDLC life cycle management.
Microservices Suitable, but balanced.
Gaming Applications Suitable, but balanced.
Caching Servers Suitable, but balanced.

Use Case	Description
Web Servers	Suitable for a balanced mix of compute, memory, and networking.
Application Servers	Suitable for backend applications that handle non-heavy compute, memory, and networking.
Small to Medium Databases	Applicable where computing and memory are not heavily used.
Development and Test Environments	Suitable for balanced SDLC life cycle management.
Microservices	Suitable, but balanced.
Gaming Applications	Suitable, but balanced.
Caching Servers	Suitable, but balanced.

Compute Optimized

Ideal for compute-bound applications that need `high-performance processors`.

Compute Optimized

Use Case Description
Batch Processing Workloads Suitable for applications that use significant computational power.
High Performance Web Servers For servers that handle high traffic and require strong performance.
Media Transcoding Suitable for media encoding and transcoding tasks for video and audio processing.
High Performance Computing (HPC) Ideal for scientific modeling, simulations, and other HPC workloads that demand high processing power.
Gaming Servers Suitable for multiple players, high performance.
Ad Server Engines For real-time ad-serving servers.
Machine Learning Inference Requires rapid computation.
Scientific Modeling and Simulation Suitable for complex simulations.
Examples
Batch Processing Workloads : Large-scale data processing in Hadoop clusters, 3rd Party Example: Apache Hadoop, Apache Spark
High Performance Web Servers : High traffic e-commerce websites like Amazon, eBay, 3rd Party Example: NGNIX (Pronouncation: EN-jin-EKS), HAProxy
Media Transcoding : Video streaming platforms like Netflix, processing multiple media files on the fly, 3rd Party Example: FFmpeg, AWS Elemental MediaConvert

Use Case	Description
Batch Processing Workloads	Suitable for applications that use significant computational power.
High Performance Web Servers	For servers that handle high traffic and require strong performance.
Media Transcoding	Suitable for media encoding and transcoding tasks for video and audio processing.
High Performance Computing (HPC)	Ideal for scientific modeling, simulations, and other HPC workloads that demand high processing power.
Gaming Servers	Suitable for multiple players, high performance.
Ad Server Engines	For real-time ad-serving servers.
Machine Learning Inference	Requires rapid computation.
Scientific Modeling and Simulation	Suitable for complex simulations.

Memory Optimized

Ideal for `memory-intensive applications` and large enterprises.
Use Case Description
In-Memory Databases Running in-memory databases like Redis, Memcached, or SAP HANA that require high memory capacity and low latency to store and process large data sets in memory.
Real-time Big Data Analytics Performing real-time analytics on large datasets using tools like Apache Spark or Hadoop, where processing speed is crucial, and large memory resources are required to keep data in memory.
HPC for Genomics Analyzing genetic data in fields like bioinformatics, where processing large-scale DNA sequencing data in memory is necessary for quick analysis.
In-Memory Caching Implementing large-scale in-memory caches that store and serve frequently accessed data, reducing access times and improving application performance.
Large-scale Enterprise Applications Running memory-intensive enterprise applications such as SAP ERP or Oracle databases that need substantial memory to maintain performance under heavy workloads.
Machine Learning and AI Model Training Training machine learning models on large datasets that need to be loaded into memory for faster processing, particularly for deep learning algorithms.

Use Case	Description
In-Memory Databases	Running in-memory databases like Redis, Memcached, or SAP HANA that require high memory capacity and low latency to store and process large data sets in memory.
Real-time Big Data Analytics	Performing real-time analytics on large datasets using tools like Apache Spark or Hadoop, where processing speed is crucial, and large memory resources are required to keep data in memory.
HPC for Genomics	Analyzing genetic data in fields like bioinformatics, where processing large-scale DNA sequencing data in memory is necessary for quick analysis.
In-Memory Caching	Implementing large-scale in-memory caches that store and serve frequently accessed data, reducing access times and improving application performance.
Large-scale Enterprise Applications	Running memory-intensive enterprise applications such as SAP ERP or Oracle databases that need substantial memory to maintain performance under heavy workloads.
Machine Learning and AI Model Training	Training machine learning models on large datasets that need to be loaded into memory for faster processing, particularly for deep learning algorithms.

Accelerated Computing

Suitable for `HPC (High Performance Computing)` applications.
Use Case Description
Machine Learning Inference Enhance performance for deep learning models by leveraging GPU-based instances for faster predictions and real-time analysis.
Graphics Rendering Run complex graphics processing tasks such as 3D rendering, video encoding, and visual effects creation using GPU acceleration.
High-Performance Computing (HPC) Execute parallel computations for scientific simulations, financial modeling, and computational fluid dynamics with faster results.
Data Pattern Matching Speed up workloads that involve extensive pattern matching, such as genome sequencing or large-scale data analysis, with FPGA-based instances.
Cryptography Perform high-speed cryptographic operations like encryption and decryption using hardware accelerators for enhanced security and efficiency.

Use Case	Description
Machine Learning Inference	Enhance performance for deep learning models by leveraging GPU-based instances for faster predictions and real-time analysis.
Graphics Rendering	Run complex graphics processing tasks such as 3D rendering, video encoding, and visual effects creation using GPU acceleration.
High-Performance Computing (HPC)	Execute parallel computations for scientific simulations, financial modeling, and computational fluid dynamics with faster results.
Data Pattern Matching	Speed up workloads that involve extensive pattern matching, such as genome sequencing or large-scale data analysis, with FPGA-based instances.
Cryptography	Perform high-speed cryptographic operations like encryption and decryption using hardware accelerators for enhanced security and efficiency.

Storage Optimized

Tailored for `workloads requiring high, sequential read/write access` to large data sets on local storage.
Use Case Description
High-Frequency OLTP Ideal for workloads requiring fast, low-latency access to large volumes of transactional data.
Big Data Analytics Optimize the processing of large data sets with high sequential read and write throughput.
Data Warehousing Suitable for workloads that need to manage and query large-scale databases efficiently.
Log or Data Processing Efficiently handle high-speed processing of log files, streaming data, or large datasets.
NoSQL Databases Enhance performance for NoSQL databases that require low-latency, high-random I/O operations.
Cache Storage Ideal for in-memory databases or caching systems that demand high IOPS for fast data retrieval.

Use Case	Description
High-Frequency OLTP	Ideal for workloads requiring fast, low-latency access to large volumes of transactional data.
Big Data Analytics	Optimize the processing of large data sets with high sequential read and write throughput.
Data Warehousing	Suitable for workloads that need to manage and query large-scale databases efficiently.
Log or Data Processing	Efficiently handle high-speed processing of log files, streaming data, or large datasets.
NoSQL Databases	Enhance performance for NoSQL databases that require low-latency, high-random I/O operations.
Cache Storage	Ideal for in-memory databases or caching systems that demand high IOPS for fast data retrieval.

Nitro-based

Enables `higher IOPS provisioning for EBS volumes`, offering up to 64,000 IOPS per volume, compared to 32,000 on other instances.
Use Case Description
Bare Metal Workloads Ideal for applications requiring direct access to physical hardware without virtualization overhead.
High-Performance Databases Suitable for running large, high-performance databases that demand low latency and high throughput.
Advanced Networking Enhanced networking capabilities for workloads requiring advanced networking features such as enhanced networking or SR-IOV.
High IOPS Storage Supports high IOPS storage systems for applications needing fast, low-latency storage performance.
Security-Sensitive Applications Perfect for security-sensitive applications requiring hardware-based isolation and encryption.
Virtualization Overhead Elimination Eliminates virtualization overhead for workloads requiring full access to underlying hardware resources.
Examples

Bare Metal Workloads

Bare Metal Workloads on AWS EC2 provide the highest level of performance and control available in the cloud. They are best suited for applications requiring direct access to hardware or those that need to meet strict compliance and licensing requirements. However, they come with added complexity and cost considerations, making them ideal for specific, high-demand workloads.

Running hypervisor-free environments for high-performance computing, such as financial trading platforms that require direct access to hardware for low-latency processing.

3rd Party Components:
VMware ESXi (for on-premises to cloud migration),
Oracle Real Application Clusters (RAC) for database workloads.

Use Case	Description
Bare Metal Workloads	Ideal for applications requiring direct access to physical hardware without virtualization overhead.
High-Performance Databases	Suitable for running large, high-performance databases that demand low latency and high throughput.
Advanced Networking	Enhanced networking capabilities for workloads requiring advanced networking features such as enhanced networking or SR-IOV.
High IOPS Storage	Supports high IOPS storage systems for applications needing fast, low-latency storage performance.
Security-Sensitive Applications	Perfect for security-sensitive applications requiring hardware-based isolation and encryption.
Virtualization Overhead Elimination	Eliminates virtualization overhead for workloads requiring full access to underlying hardware resources.

Cloud Continuous Deployment (CD) Services Comparison

noreply@blogger.com (One-Ananda) — Sat, 31 Aug 2024 04:21:00 +0000

AWS Network Access Control Lists (NACLs) and Security Groups

noreply@blogger.com (One-Ananda) — Fri, 30 Aug 2024 00:03:00 +0000

AWS NACLs vs. AWS Security Groups: What's the Difference?

Feature	Security Groups	Network Access Control Lists (NACLs)
Statefulness	Security Groups are stateful. They remember things like whether a request was allowed, so they automatically allow return traffic without us having to do anything extra.	NACLs are stateless, meaning they don't remember anything about previous requests. Each request is treated like it's the first one.
Where They Work	Security Groups work at the instance level (or for other specific resources), so they control traffic for individual instances.	NACLs work at the subnet level, so they control traffic for all instances in a subnet.
Inbound Rules	Security Groups check all their rules, and if any rule allows the traffic, it's allowed in. They don’t care about the order.	NACLs follow their rules in a specific order, starting from the lowest number. Once a match is found, that's it—no more rules are checked.
Outbound Rules	Security Groups automatically allow return traffic if it was allowed in. So if someone connects in, their responses are allowed out without extra rules.	With NACLs, we need to set up rules for both inbound and outbound traffic. If we want traffic to go out, we have to explicitly allow it.
Default Settings	The default Security Group blocks everything from coming in, but it allows everything to go out unless we say otherwise.	By default, the NACL that comes with our VPC allows everything in and out. But if we create a new NACL, it blocks everything until we set up rules. In summary, the default NACL will allow traffic by default, but the ones we create will block everything by default.
How Rules Are Ordered	Security Groups don’t have rule numbers. They look at all the rules and use the most permissive one that applies.	NACLs have numbered rules, and they check them in order from lowest to highest. The first rule that matches gets applied.
Logging and Monitoring	Security Groups can log changes through AWS CloudTrail, and we can monitor traffic with VPC Flow Logs.	NACLs don’t keep track of what they block or allow by default. We’ll need to set up something like VPC Flow Logs to see what’s happening.
How They’re Assigned	Security Groups need to be assigned to specific instances or resources; they’re not automatically applied.	Every subnet in a VPC has to be associated with a NACL. If we don’t pick one, it’ll get the default NACL.
Best Use Case	Security Groups are our go-to for securing individual instances. They’re perfect for managing who can connect to our servers and how.	NACLs are great for adding an extra layer of security at the subnet level, especially when we want to control traffic between different subnets.
How They’re Managed	Security Groups are managed at the instance level or for specific AWS resources.	NACLs are managed at the subnet level in our VPC.
How Rules Are Applied	Security Groups check all rules at once. If any rule allows the traffic, it’s allowed.	NACLs apply rules in a set order, and once a match is found, that rule is applied, and the rest are ignored.
Return Traffic	Security Groups automatically allow return traffic for any inbound connections, so we don’t need to worry about it.	With NACLs, we need to create rules for both incoming and outgoing traffic separately. Return traffic won’t be allowed unless we set up a rule for it.

What AWS Security Groups and NACLs Have in Common?

Feature	Description
IP Address Filtering	Both Security Groups and NACLs can filter traffic based on specific IP address ranges (CIDR blocks). This helps us manage which IP addresses are allowed or denied access to our resources.
Protocol Support	Both Security Groups and NACLs can handle traffic using protocols like TCP, UDP, ICMP, and others, giving us flexibility in managing network traffic.
Allow/Deny Rules	Both can explicitly allow or deny traffic based on rules we set up, providing us with control over what traffic is permitted or blocked.
VPC Integration	Both Security Groups and NACLs are integral to a Virtual Private Cloud (VPC) environment, playing a key role in securing our network within AWS.
Monitoring with VPC Flow Logs	Both can be monitored using VPC Flow Logs, allowing us to track the traffic that is allowed or denied by our rules, helping us maintain security and troubleshoot issues.
Ease of Modification	We can modify both Security Groups and NACLs at any time, updating the rules as our security needs change.
Network Layer Security	Both provide an important layer of network security within AWS, with Security Groups focusing on instance-level protection and NACLs focusing on subnet-level control.

Azure NAT Gateway Process

noreply@blogger.com (One-Ananda) — Tue, 27 Aug 2024 00:11:00 +0000

Azure NAT Gateway Process - Managing Outbound Traffic

Cloud Continuous Integration (CI) Services Comparison

noreply@blogger.com (One-Ananda) — Sun, 25 Aug 2024 09:24:00 +0000

C# - out - Reference Programming - Deep dive

noreply@blogger.com (One-Ananda) — Sat, 24 Aug 2024 08:55:00 +0000

'out' - Reference Programming - Deep dive

This article demonstrates how to use out keyword with different aspects,

In C# using 'out' keyword is indicating that the parameter is passed by reference rather than value, that means, any changes made to the parameter will be made available outside of the method.

The other purpose of using out is, we can return multiple parameters from a method, this might be very useful in cases where we need multiple values to be evaluated in the caller function.

We will see how this is happening!

Purpose

The primary objective of this project is to showcase how the out keyword can be utilized in different programming scenarios. This includes:

Returning multiple values from a method.
Handling method overloading with out parameters.
Parsing strings using TryParse with out.
Assigning values within methods using the out keyword.

Examples

The project covers the following examples:

Basic Example with out Parameter
- Demonstrates how the out keyword can be used to return a value from a method.

Calling method

            int x, y;
            
            y = Multiply(out x);

            Console.WriteLine($"x = {x}, y = {y}");

Out Method

        static int Multiply(out int a)
        {
            // The a needs to be assigned before the control leaves the method
            // if not, the compiler error will happen
            a = 10; 
            return a * a;
        }

Using out for Multiple Return Values
- Illustrates how to use the out keyword to return multiple values from a method, such as quotient and remainder from a division operation.

Calling method

            int dividend = 17, divisor = 3;
            int quotient, remainder;

            Divide(dividend, divisor, out quotient, out remainder);

            Console.WriteLine($"Quotient: {quotient}, Remainder: {remainder}");

Out Method

        static void Divide(int dividend, int divisor, out int quotient, out int remainder)
        {
            quotient = dividend / divisor;
            remainder = dividend % divisor;
        }

Using out with TryParse
- Shows how out is commonly used with the TryParse method to convert strings to numeric types safely.

Calling method

            string input = "123";

            if (int.TryParse(input, out int result))
            {
                Console.WriteLine($"Parsing successful: {result}");
            }
            else
            {
                Console.WriteLine("Parsing failed.");
            }
            Console.WriteLine(string.Empty);

           
            input = "123A";

            if (int.TryParse(input, out result))
            {
                Console.WriteLine($"Parsing successful: {result}");
            }
            else
            {
                Console.WriteLine("Parsing failed.");
            }

Method Overloading with out
- Explores how method overloading works when methods differ by their out parameters, and how it can be used to provide multiple functionalities.

Calling method

            int overloadResult;

            DoSomething(5, out overloadResult); // Calls the first method
            Console.WriteLine(overloadResult);   // Output: 10

            DoSomething(5, 3, out overloadResult); // Calls the second method
            Console.WriteLine(overloadResult);     // Output: 8

Out Method

        static void DoSomething(int a, out int b)
        {
            b = a * 2;
        }
        static void DoSomething(int a, int c, out int b)
        {
            b = a + c;
        }

Output

Key Takeaways

Mandatory Assignment: The out parameter must be assigned a value within the method before the method returns. If not, the compiler will generate an error.
Difference from ref: Unlike ref, out parameters do not need to be initialized before passing them to a method, but they must be initialized within the method.
Multiple Return Values: out is an excellent way to return multiple values from a method without using complex data structures.
Overloading Flexibility: Method overloading with out parameters allows for flexible method signatures and multiple implementations.

C# - ref - Reference Programming - Deep dive

noreply@blogger.com (One-Ananda) — Thu, 22 Aug 2024 23:08:00 +0000

'ref' - Reference Programming - Deep dive

In C# using 'ref' keyword is indicating that the parameter is passed by reference rather than value, that means, any changes made to the parameter will be made available outside of the method.

The other purpose of using ref is, we can return multiple parameters from a method, this might be very useful in cases where we need multiple values to be evaluated in the caller function.

We will see how this is happening!

Example 1: Basic implementation of 'ref'

            int num = 10;
            Console.WriteLine($"Before method call: {num}");

            ModifyValue(ref num);

            Console.WriteLine($"After method call: {num}");

            // Output
            // Before method call: 10
            // After method call: 20
        }

Calling method

        static void ModifyValue(ref int x)
        {
            x = x * 2;
        }

Example 2: Multiple 'ref' implementation

            int result1 = 0, result2 = 0;

            CalculateValues(5, 3, ref result1, ref result2);

            Console.WriteLine($"Sum: {result1}, Difference: {result2}");

Calling method

            static void CalculateValues(int a, int b, ref int sum, ref int difference)
            {
                sum = a + b;
                difference = a - b;
            }

Example 3: Handling Reference Types

            // Create a new Person object and set its Name property.
            Person person = new Person { Name = "Alice" };
            Console.WriteLine($"Before: {person.Name}");

            // Pass the person object by reference.
            ModifyPerson(ref person);

            // The reference to person has been changed inside the method.
            Console.WriteLine($"After: {person.Name}");

Calling method

        // Method that takes a Person object by reference.
        static void ModifyPerson(ref Person p)
        {
            // Create a new Person object and assign it to the parameter.
            p = new Person { Name = "Bob" };
        }

Example 3: Demonstrating String Behavior

            // Create a new Person object and set its Name property.
            Person person = new Person { Name = "Alice" };
            Console.WriteLine($"Before: {person.Name}");

            // Pass the person object by reference.
            ModifyPerson(ref person);

            // The reference to person has been changed inside the method.
            Console.WriteLine($"After: {person.Name}");

Calling method

        // Method that takes a Person object by reference.
        static void ModifyPerson(ref Person p)
        {
            // Create a new Person object and assign it to the parameter.
            p = new Person { Name = "Bob" };
        }

Example 4: Using ref in string

            string text = "Hello";
            Console.WriteLine($"Before: {text}");

            // Pass the string by reference.
            ModifyString(ref text);

            // The string reference should point to the new string value.
            Console.WriteLine($"After: {text}");

Calling method

        static void ModifyString(ref string s)
        {
            // Reassign the reference to a new string instance.
            s = "World";
        }

Important point to be noted: Even though by natural the string is reference type, it will not hold the values across methods as it is immutable, that means everytime you are assining a new value it will start referring to a new reference pointer.

Example 5: Using ref in Recursive Methods

            int number = 1;
            Console.WriteLine($"Original Number: {number}");

            IncrementRef(ref number, 5);

            Console.WriteLine($"Incremented Number: {number}");

Calling method

            static void IncrementRef(ref int num, int limit)
            {
                if (num < limit)
                {
                    num++;
                    IncrementRef(ref num, limit);
                }
            }

Example 6: Without Using ref but achive the same functionality

            List<string> LstStr = new List<string>();
            LstStr.Add("Adding string 1");
            Console.WriteLine($"Original Count: {LstStr.Count}");

            ProcessLstStr(LstStr);

            Console.WriteLine($"Current Count: {LstStr.Count}");

Calling method

            private static void ProcessLstStr(List<string> lstStr)
            {
                // Adding values, but not returning
                lstStr.Add("Adding new string");
                lstStr.Add("Adding another new string");
            }

Example 7: With and without Using ref - Performance considerations

Without ref

            LargeStruct largeStruct = new LargeStruct(1000000);
            Console.WriteLine("Starting Without ref...");

            for (int i = 0; i < 1000; i++)
            {
                ProcessLargeStruct(largeStruct);
            }

            Console.WriteLine("Finished Without ref.");

Calling method

        static void ProcessLargeStruct(LargeStruct ls)
        {
            // Processing large struct...
            ls.Data[0] = 42; // Modify just to simulate some processing
        }

Performance Considerations:

Copying: Each time ProcessLargeStruct is called, a full copy of largeStruct is made. If the struct is large (e.g., contains a large array), this copying process can be slow and memory-intensive.
Complexity: The overhead increases with the size of the struct and the number of times the method is called, as more time and memory are required to create and manage the copies.

With ref

            LargeStruct largeStruct = new LargeStruct(1000000);
            Console.WriteLine("Starting With ref...");

            for (int i = 0; i < 1000; i++)
            {
                ProcessLargeStruct(ref largeStruct);
            }

            Console.WriteLine("Finished With ref.");

Calling method

        static void ProcessLargeStruct(ref LargeStruct ls)
        {
            // Processing large struct...
            ls.Data[0] = 42; // Modify just to simulate some processing
        }

Performance Considerations:

No Copying: By passing the struct with ref, no copying occurs. The method operates directly on the original struct, significantly reducing the time and memory overhead.
Direct Access: Since the struct is passed by reference, any modifications made within the method are applied directly to the original struct, which can be more efficient.

Performance Comparison Summary

Memory Usage & Execution Time:

Without ref: Memory usage and Execution Time increases due to the creation of multiple copies of the large struct.
With ref: Memory usage and Execution Time are reduced as no copies are made; the method operates directly on the original struct.

Output

Key Points

Parameter Initialization: The parameter passed to a method with ref must be initialized before being passed to the method. If not initialized, the compiler will throw an error.

Consistent Usage: You must use the ref keyword both in the method definition and when calling the method. Omitting ref in either place will result in a compilation error.

Reference: Using ref allows you to modify the value of the argument in the caller's scope, which is different from passing parameters by value, where the method works with a copy of the argument.

AWS Learning 001 - Amazon EC2 - 001 - Instance Components

noreply@blogger.com (One-Ananda) — Sun, 18 Aug 2024 13:02:00 +0000

Amazon Elastic Computing Cloud (EC2) is a computing service from Amazon Web Services (AWS), this is based on virtual machine concept, where users can rent the machines of their needed configuration to work on the computing part, this is categorized as Infrastructure as a Service (IaaS)

This is one of the earliest services released by Amazon after Simple Storage Services (S3) and Simple Queue Service (SQS) (A message queuing service),
Amazon EC2 instances are virtual servers the provide computing resources need to run the applications on the cloud.

It enables the users to run their application on virtual servers known as instances without need to invest in physical hardware, with EC2 we can scale the resources up and down on need basis, making it to ideal for the business ranging from small to large enterprises.

Amazon EC2 Instance Components - There are several components comes to play when it comes to instance creation.

Understanding EC2 Instance Components

AMI - Amazon Machine Image (Can be Windows AMI, Linux, MacOS)
Instance Type
Instance Size

Configuring Instances

Number of Instances
Billing Type
Configure VPC (Virtual Private Cloud)
Configure Subnet
Configure IP Settings (Public, Private, IPv4, IPv6)
Configure Domain / Directory Integration
Configure Placement Group
Configure IAM Roles
Configure Shutdown Behavior
Enable Termination Protection
Option to Mount EFS (Elastic File System)
Configure User Data (Scripts/Commands on Launch)

Storage

Add Storage of Preferred Type
Determine EBS (Elastic Block Store) Volumes When the Instance is Terminated

Security Groups

Add Security Groups to Act as a Firewall
Manage Inbound/Outbound Traffic via Security Groups
Modify at Any Time

Launch Instance

Confirm setting and launch the instance

Key Things to Note:

AMIs cannot be modified post-launch.
There is no option to change the key pair after instance launch.
Instance types and sizes can't be changed post launch
EIPs (Elastic IPs) are static, won't changed even after instance restart / stopped and started
Data on ephemeral storage (instance store) will be lost if the instance is terminated / stopped but will not lost if the instance is restarted
Security groups are stateful, if you allow any inbound traffic, automatically the outbound is allowed
The instance's public IP address will be changed if it is started and stopped and will not lost if the instance is restarted, additionally if you are using EIP the IP remains the same.
Termination protection disabled by default
EC2 instances can be part of Auto Scaling Group (ASG)
Basic monitoring is available using CloudWatch

Comprehensive Cloud Services Comparison

noreply@blogger.com (One-Ananda) — Wed, 14 Aug 2024 14:49:00 +0000

User Configuration Preloading - Performance management

noreply@blogger.com (One-Ananda) — Sun, 11 Aug 2024 03:48:00 +0000

User Configuration Preloading

Performance management question:

I am having an application which the each user configuration is rendered in JSON format, the JSON is huge for each user but the user base is low as within 100 count

Since the JSON configuration is huge to load, can I load the list of JSON for all users at the time of initialization (say in the morning time, every day), so that it be served whenever any particular user is logging in, so that I can improve the performance ?

Answer

Preloading the JSON configuration for all users at the time of application initialization can really improve performance, especially given the scenario where the user base is small (around 100 users). This approach can reduce the complexity of repeatedly loading large JSON files during each user's login, thereby speeding up response times.

Considerations for Preloading JSON Configurations:

Memory Usage:

Ensure that your application has enough memory to hold all the preloaded JSON configurations simultaneously. Since the configurations are large, assess the total memory footprint.

Initialization Time:

The initial loading process might take some time, especially if the JSON files are very large. Consider scheduling this initialization during low-traffic periods (e.g., early morning) to avoid impacting users.

Data Consistency:

If the JSON configurations are subject to change, you’ll need a strategy to update the preloaded data when changes occur. This could be handled by reloading specific configurations or refreshing all configurations at regular intervals.

Caching Strategy:

Implement an effective caching strategy. You could store the preloaded configurations in an in-memory cache, such as using Redis or an in-process memory cache if your application runs on a single server.

Fallback Mechanism:

Have a fallback mechanism in case the preloading fails or if a configuration is requested that was not preloaded (e.g., a new user).

Concurrency:

Ensure thread safety when accessing the preloaded configurations. Use appropriate locking mechanisms or thread-safe collections.

Monitoring and Alerts:

Set up monitoring to track memory usage, load times, and the performance impact of this preloading strategy. This will help in fine-tuning the process.

Security considerations:

Use data encryption if the data is using sensitive information
Provide strong access control to avoid data leak

Implementation Outline:

Step 1: During application startup, load and parse all user JSON configurations into memory.
Step 2: Store the configurations in a thread-safe in-memory data structure (like a dictionary or a cache).
Step 3: When a user logs in, retrieve their configuration from the preloaded data instead of loading it from disk.
Step 4: Periodically refresh the preloaded data or update it as necessary based on changes.

Conclusion

Assuming if the JSON does not contain any sensitive information, if it contains we need to go for a different approach like

Encryption
Access Control
Secure Initialization
Tokenization
Minimal Data Exposure

Lazy Initialization Vs Dependency Injection

noreply@blogger.com (One-Ananda) — Sat, 10 Aug 2024 11:48:00 +0000

Introduction

In software designing one can easily get deceived with the two concepts as one, Lazy Initialization and Dependency Injection

Here we are going to see the key differences between Lazy Initialization and Dependency Injection which may sound similar, but in fact not, both the SW design concepts are distinct by nature, we will see this with examples

Lazy Initialization

Lazy Initialization is used to delay the object creation process until it is actually needed,

This can improve the performance of the application, we can achieve this by using Lazy class which ensures the object is created when it is accessed for first time

Dependency Injection

Dependency Injection (DI) is a design pattern that helps to decouple the creation of objects from it's usage, In DI, objects are passed their dependencies rather than creating them internally

This improves

Testability,
Maintainability,
Flexibility

DI is commonly implemented using an IoC (Inversion of Control) container, which manages the lifecycle of the objects

DI Analogy

Imagine you are running a restaurant, you tasked the chef to prepare the meal as well as bring ingredients from store whenever any order comes up, this is without DI,

Now with DI, you asked the chef to do only to prepare the meal, and provide the ingredients whenever needed by restaurant or other person (here we call it DI container)

In this analogy:

Restaurant: DI container

Chef: Your application or service

Ingredients: Dependencies (services)

Customer’s Order: Request for a service

Use Case for Dependency Injection (DI)

Scenario: You have an application with multiple components that depend on various services, such as a logging service, database access, and configuration management.

Use Case: DI helps in injecting these dependencies into your components, making the code modular and easier to test. For example, you can inject a mock logging service for unit tests without changing the actual implementation.

Lazy Initialization Analogy

Imagine you have a book that you only want to read if you have free time. Instead of carrying it around all day, you keep it on the shelf and only take it out when you decide to read it. This is like Lazy Initialization in programming.

Use Cases for Lazy Initialization

Scenario: You have a service or object that is costly to create (e.g., due to heavy computation, large memory usage, or network calls).

Use Case: Use Lazy Initialization to defer the creation of this object until it is actually needed, thus avoiding the overhead of creating it upfront if it may not be used.

Basic to advanced Implicit Conversions in C#

noreply@blogger.com (One-Ananda) — Wed, 10 Jul 2024 04:40:00 +0000

Here We can see Implicit Conversions examples range from basic to advanced scenarios, demonstrating how implicit conversions can be used in various contexts.

Overview

Implicit conversions in C# allow certain types to be converted to other types without explicit casting. This feature is useful for ensuring type safety and simplifying code. This project provides examples of implicit conversions, including numeric type conversions, class inheritance, and custom conversion operators.

public static void Example1()

{

int intVal = 123;

double doubleVal = intVal; // Implicit conversion from int to double

Console.WriteLine(doubleVal); // Output: 123

}

public static void Example2()

{

int IntValue = 10;

long LongValue;

// Converting int to long is easy

LongValue = IntValue;

// The above code will work as we are converting from small memory size to bigger one

Console.WriteLine(LongValue); // Output: 10

}

public static void Example3()

{

int IntValue = 10;

long LongValue = 1000;

// Converting int to long is NOT easy possible

// Un comment the following line to see the compile time error

//IntValue = LongValue;

// The above code will NOT work as we are converting from bigger memory size to smaller one,

// Even though we are assigning the values to int that is capable of holding

//Compiler Error: Cannot implicitly convert type 'long' to 'int'.An explicit conversion exists(are you missing a cast?)

}

Basic level examples

Implicit Conversion Between Numeric Types

Converting a smaller numeric type to a larger numeric type (e.g., int to double).
Converting int to long
Converting from bigger memory size to smaller one (will not compile/work)

Medium level examples

Implicit Conversion Between Classes

Converting from a derived class to a base class.

internal class Customer

{

public string Name { get; set; }

}

class Local_Customer : Customer

{

public void ContactInPerson()

{

Console.WriteLine("ContactInPerson!");

}

class National_Customer : Customer

{

public void ContactViaPhone()

{

Console.WriteLine("ContactViaPhone!");

}

class International_Customer : Customer

{

public void ContactViaVideoCall()

{

Console.WriteLine("ContactViaVideoCall!");

}

Local_Customer localCustomer = new Local_Customer { Name = "Mason Turner" };

National_Customer nationalCustomer = new National_Customer { Name = "Emma Coleman" };

International_Customer internationalCustomer = new International_Customer { Name = "Jackson Hayes" };

CustomerService service = new CustomerService();

service.ContactCustomer(localCustomer);

service.ContactCustomer(nationalCustomer);

service.ContactCustomer(internationalCustomer);

In the example we can see the following things:

Method Overloading: Allows different methods with the same name to handle various types.
Implicit Conversion: The derived classes are implicitly converted to the base class Customer when needed.
Polymorphism: The correct method is chosen based on the type of the argument passed, demonstrating polymorphism in action.

Advanced level examples

Creating a custom implicit conversion between two user-defined types.

In the example we can see the following things:

The USD class has an implicit conversion operator that converts an EUR instance to USD.
The EUR class has an implicit conversion operator that converts a USD instance to EUR.
The conversion rates are hardcoded in the example (1 EUR = 1.10 USD and 1 USD = 0.91 EUR)

internal class Currency

{

public class USD

{

public decimal Amount { get; }

public USD(decimal amount)

{

Amount = amount;

}

// Implicit conversion from EUR to USD

public static implicit operator USD(EUR eur)

{

// Assuming a conversion rate of 1 EUR = 1.10 USD

return new USD(eur.Amount * 1.10m);

}

public override string ToString()

{

return $"{Amount} USD";

}

public class EUR

{

public decimal Amount { get; }

public EUR(decimal amount)

{

Amount = amount;

}

// Implicit conversion from USD to EUR

public static implicit operator EUR(USD usd)

{

// Assuming a conversion rate of 1 USD = 0.91 EUR

return new EUR(usd.Amount * 0.91m);

}

public override string ToString()

{

return $"{Amount} EUR";

}

// Calling

public static void Example1()

{

// Convert EUR to USD

Console.WriteLine("Convert EUR to USD");

EUR euros = new EUR(100);

USD dollars = euros; // You can note there is no explicit assignment

Console.WriteLine(dollars); // Output: 110 USD

}

public static void Example2()

{

// Convert USD to EUR

Console.WriteLine("Convert USD to EUR");

USD usDollars = new USD(100);

EUR eurosFromDollars = usDollars;// You can note there is no explicit assignment

Console.WriteLine(eurosFromDollars); // Output: 91 EUR

}

// Convert EUR to USD
Console.WriteLine("Convert EUR to USD");
EUR euros = new EUR(100);
USD dollars = euros; // You can note there is no explicit assignment
Console.WriteLine(dollars); // Output: 110 USD

// Convert USD to EUR
Console.WriteLine("Convert USD to EUR");
USD usDollars = new USD(100);
EUR eurosFromDollars = usDollars;// You can note there is no explicit assignment
Console.WriteLine(eurosFromDollars); // Output: 91 EUR

I hope we have learnt what we can do with Implicit conversions at advance level, The complete executable source code is available in the following link

https://github.com/oneananda/C_Sharp_Examples/tree/main/Implicit_Conversionshttps://github.com/oneananda/C_Sharp_Examples/tree/main/Implicit_Conversions

Implementing RequestDelegate in ASP.NET Core

noreply@blogger.com (One-Ananda) — Sun, 07 Jul 2024 12:34:00 +0000

In ASP.NET Core the RequestDelegate is a delegate that represents a function that can process an HTTP request. It is a fundamental part of the middleware pipeline in ASP.NET Core and is used to define the sequence of operations that handle an HTTP request and produce a response.

This will do the following process

Process an Incoming Request: Each middleware component can inspect, modify, or process the incoming HTTP request, Except for "No-Op Middleware" which is just passing the command to next Middleware (does nothing other than this, and not recommended)
Modify the Response (Optional): Middleware components can also modify the HTTP response before it is sent back to the client. This step is optional and depends on the middleware's purpose.
Call the Next Middleware Component in the Pipeline: Middleware components usually call the next component in the pipeline to continue the request processing. This is done by invoking the RequestDelegate passed to the middleware.

Step 1 : Create a CustomMiddleware Class:

The CustomMiddleware class has a constructor that accepts a RequestDelegate parameter, which represents the next middleware in the pipeline. The InvokeAsync method is where the request processing logic is implemented. Before calling _next(context), you can add logic to handle the request. After calling _next(context), you can add logic to handle the response.

public class CustomMiddleware

{

private readonly RequestDelegate _next;

public CustomMiddleware(RequestDelegate next)

{

_next = next;

}

public async Task Invoke(HttpContext context)

{

// Do something with the request before calling the next middleware

Console.WriteLine($"Handling request in CustomMiddleware");

await _next(context);

// Do something with the response after calling the next middleware

Console.WriteLine($"Finished handling request in CustomMiddleware");

}

Step 2: Create a CustomMiddlewareExtensions Class:

This class contains an extension method UseCustomMiddleware to add the custom middleware to the application builder.

public static class CustomMiddlewareExtensions

{

/// <summary>

/// Extension method to add the CustomMiddleware to the application's request pipeline.

/// </summary>

/// <param name="app">The IApplicationBuilder instance.</param>

/// <returns>The IApplicationBuilder instance with the CustomMiddleware added to the pipeline.</returns>

public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder app)

{

// Adds the CustomMiddleware to the application's request pipeline.

return app.UseMiddleware<CustomMiddleware>();

}

Step 3: Create a Startup Class:

In the Configure method, app.UseCustomMiddleware() adds the custom middleware to the request pipeline. app.Run() is a final middleware that processes the request and generates a response.

Output : In Console

Handling request in CustomMiddleware
Finished handling request in AdditionalMiddleware
Finished handling request in CustomMiddleware

Advanced Topics:

Short-circuiting the middleware
To Short-circuiting the middleware, we are purposefully not passing the command next and see what happens

The pipeline will closes abruptly, To see Short-circuiting uncomment the lines mentioned
public class ShortCircuitMiddleware
{
    private readonly RequestDelegate _next;
    public ShortCircuitMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Short-circuit the pipeline and generate a response
        context.Response.StatusCode = 403;
        await context.Response.WriteAsync("Forbidden");

        // Does not call the next middleware
    }
}
    
// Short-circuiting the middleware
    app.Use(async (context, next) =>
    {
        var shortCircuitMiddleware = new ShortCircuitMiddleware(next);
        await shortCircuitMiddleware.InvokeAsync(context);
    });

NoOpMiddleware

NoOpMiddleware - Does nothing other than passing the control to next middleware
 public class NoOpMiddleware
 {
     private readonly RequestDelegate _next;

     public NoOpMiddleware(RequestDelegate next)
     {
         _next = next;
     }

     public async Task InvokeAsync(HttpContext context)
     {
         // No specific processing on the request

         // Call the next middleware
         await _next(context);
     }
 }

    app.Use(async (context, next) =>
    {
        var noOpMiddleware = new NoOpMiddleware(next);
        await noOpMiddleware.InvokeAsync(context);
    });

Adding multiple middlewares to the application's request pipeline in a single extension
    public static IApplicationBuilder UseMultipleCustomMiddlewares(this IApplicationBuilder app)
    {
        // Adds the AdditionalMiddleware1 and AdditionalMiddleware2 to the application's request pipeline.
        app.UseMiddleware<AdditionalMiddleware1>();
        return app.UseMiddleware<AdditionalMiddleware2>();
    }

Conclusion
Every middleware component must at least handle the HttpContext to either process it or pass it to the next middleware.

Modifying the response and calling the next middleware are optional steps, depending on the middleware's purpose.

The extent of request processing can range from extensive modifications to simple logging or even doing nothing specific.

I hope we have learnt what RequestDelegate can do, The complete executable source code is available in the following link

https://github.com/oneananda/asp_dot_net_core_projects/tree/main/014_RequestDelegate_Implementation

ASP.NET Core Web API Advanced Versioning Strategies

noreply@blogger.com (One-Ananda) — Sat, 06 Jul 2024 08:17:00 +0000

This example demonstrates multiple advanced API versioning strategies in ASP.NET Core. This includes examples of URL Path Versioning, Query String Versioning, Header Versioning, Media Type Versioning, and explains the use of the Microsoft.AspNetCore.Mvc.Versioning library for structured version management.

We will look into following API Versioning Strategies

URL Path Versioning
Query String Versioning
Header Versioning
Media Type Versioning
ASP.NET Core API Versioning Library
Combining Multiple Versioning Strategies

URL Path Versioning: In URL path versioning, the version number is included in the URL path. This is the most straightforward approach and makes the version explicit in the endpoint.

// URL Path Versioning -- V1

[Route("api/v1/products")]

[ApiController]

public class ProductsV1 : ControllerBase

{

[HttpGet]

public IActionResult Get() => Ok("This is version 1.0");

}

// URL Path Versioning -- V2

[Route("api/v2/products")]

[ApiController]

public class ProductsV2 : ControllerBase

{

[HttpGet]

public IActionResult Get() => Ok("This is version 2.0");

}

/api/products?apiVersion=1

/api/products?apiVersion=2

Query String Versioning: With query string versioning, the version number is specified as a query parameter in the URL and it will be accessed by '[FromQuery]' attribute

// Query String Versioning

[HttpGet]

public IActionResult Get([FromQuery] string apiVersion)

{

if (apiVersion == "1.0")

{

return Ok("This is version 1.0");

}

else if (apiVersion == "2.0")

{

return Ok("This is version 2.0");

}

else

{

return BadRequest("Invalid version");

}

Header Versioning: In header versioning, the version information is included in the HTTP headers of the request and it will be accessed by '[FromHeader(Name = "api-version")]' attribute

// Header Versioning

[HttpGet]

public IActionResult Get([FromHeader(Name = "api-version")] string apiVersion)

{

if (apiVersion == "1,0")

return Ok("This is version 1.0");

else if (apiVersion == "2.0")

return Ok("This is version 2.0");

else

return BadRequest("Invalid version");

}

Media Type Versioning: Also known as "Content Negotiation," media type versioning includes the version in the Accept header using custom media types and it will be accessed by '[FromHeader(Name = "Accept")]' attribute

// Media Type Versioning

[HttpGet]

public IActionResult Get([FromHeader(Name = "Accept")] string acceptHeader)

{

if (acceptHeader.Contains("application/vnd.company.v1+json"))

return Ok("This is version 1.0");

else if (acceptHeader.Contains("application/vnd.company.v2+json"))

return Ok("This is version 2.0");

else

return BadRequest("Invalid version");

}

ASP.NET Core API Versioning Library: The ASP.NET Core API Versioning Library is a tool that simplifies implementing versioning in ASP.NET Core applications. It supports multiple versioning methods, provides comprehensive configuration options, and integrates well with ASP.NET Core's routing and dependency injection features.

Note that we need to specify the controller attribute (ApiVersion) and map that in the methods (MapToApiVersion)

// Using API Version Library

[Route("api/[controller]")]
[ApiController]
[ApiVersion("1.0")]
[ApiVersion("2.0")]
public class RegionController : ControllerBase
{
	[HttpGet]
	[MapToApiVersion("1.0")]
	public IActionResult GetV1() => Ok("This is version 1.0");

	[HttpGet]
	[MapToApiVersion("2.0")]
	public IActionResult GetV2() => Ok("This is version 2.0");
}

Combining Multiple Versioning Strategies: Combining multiple versioning strategies involves using more than one method to handle versioning. For example, you might use both URL path versioning and header versioning to provide flexibility for different clients.

// In Program.cs or Startup.cs file

builder.Services.AddApiVersioning(options =>

{

options.DefaultApiVersion = new Asp.Versioning.ApiVersion(1, 0);

options.AssumeDefaultVersionWhenUnspecified = true;

options.ReportApiVersions = true;

options.ApiVersionReader = ApiVersionReader.Combine(

new QueryStringApiVersionReader("api-version"),

new HeaderApiVersionReader("api-version"));

})

.AddApiExplorer(options =>

{

options.GroupNameFormat = "'v'VVV";

options.SubstituteApiVersionInUrl = true;

});

I hope we have learnt different versioning strategies, The complete executable source code is available in the following link

Source code for ASP.NET Core Web API with Advanced Versioning Strategies

Using Options Pattern in ASP.NET Core for managing application settings

noreply@blogger.com (One-Ananda) — Sat, 06 Jul 2024 06:40:00 +0000

To fetch a customized config values from "appsettings.json" in ASP.NET Core is never easier before, we can use "Options Pattern" to map the config values to a class

Here is an example for "Options Pattern"

Step 1: Create a appsettings.json file or add the section "AppSettings" like this

{

"AppSettings": {

"APIUrl": "MyAPIUrl",

"APIKey": "MyAPIKey"

"Logging": {

"LogLevel": {

"Default": "Information",

"Microsoft.AspNetCore": "Warning"

}

"AllowedHosts": "*"

}

Step 2: Create a class "MyAppSettings" which should reflect the type of "AppSettings"

public class MyAppSettings

{

public string APIUrl { get; set; }

public string APIKey { get; set; }

}

Step 3: Bind MyAppSettings to the ConfigureServices section

public void ConfigureServices(IServiceCollection services)

{

// Bind MyAppSettings to the configuration section

services.Configure<MyAppSettings>(_configuration.GetSection("AppSettings"));

}

Step 4: In the Controller inject it and get access to the values from configuration

public class HomeController : Controller

{

	private readonly MyAppSettings _myAppSettings;

	public HomeController(IOptions<MyAppSettings> myAppSettings)

{

		_myAppSettings = myAppSettings.Value;

}

	public IActionResult Index()

{

		ViewBag.APIUrl = _myAppSettings.APIUrl;

		ViewBag.APIKey = _myAppSettings.APIKey;            

		return View();

}

}

The complete executable source code is available in the following link :

Options_Pattern_Configuration_Example Source code

Creating custom middleware in asp.net core

noreply@blogger.com (One-Ananda) — Sat, 06 Jul 2024 04:35:00 +0000

The "Middleware Request Logging" application, is designed to demonstrate how to implement custom middleware for logging HTTP requests in an ASP.NET Core application. Here is an overview of the project concept:

The application illustrates the creation of a custom middleware in ASP.NET Core that logs details of incoming HTTP requests. This can be useful for monitoring and debugging purposes, providing insights into the requests hitting your application.

Key Components

Custom Middleware: The core of the project is a custom middleware component that intercepts HTTP requests and logs relevant information.

Middleware Registration: The middleware is registered in the ASP.NET Core pipeline, ensuring it processes requests as they come in.

Logging: The middleware uses a logging mechanism (like ILogger) to record details such as the HTTP method, URL, headers, and possibly the body of the request.

Steps

Create Middleware Class: Implement a class that defines the middleware logic. This class should have a InvokeAsync method that takes an HttpContext parameter.

public async Task InvokeAsync(HttpContext context)

{

_logger.LogInformation($"Request: {context.Request.Method} {context.Request.Path}");

await _requestDelegate(context);

}

Use ILogger: Inject an ILogger instance into the middleware class to log the request details.


    
private readonly ILogger _logger;

public RequestLoggingMiddleware(ILogger logger)

{

_logger = logger;

Create an Extension method: In a separate class create an extension method

public static class RequestLoggingMiddlewareExtension
{
	public static IApplicationBuilder UseRequestLogging(this IApplicationBuilder builder)
	{
		return builder.UseMiddleware<RequestLoggingMiddleware>();
	}
}

Register Middleware: In the Startup class, register the custom middleware in the Configure method using the app.UseMiddleware<YourMiddlewareClass>() syntax.


    app.UseRequestLogging();

Run the Application: Build and run the application to see the middleware in action. HTTP requests will be logged as they are processed.

The complete executable source code is available in the following link :

https://github.com/oneananda/asp_dot_net_core_projects/tree/main/003_Middleware_Request_Logging

OneAnanda

Handling Multiple Value Returns in C#: Techniques and Best Practices

Handling Multiple Value Returns in C#: Techniques and Best Practices

1. Out Parameters

2. Tuples

3. Custom Classes or Structs

4. KeyValuePair

5. Arrays and Collections

Wrapping It Up

Amazon Inspector

Summary of Supported and Unsupported Services:

Hot Partition in DynamoDB

Scenario:

Problem:

How to Avoid Hot Partitions:

Summary:

AWS DDoS Protection Services

AWS DDoS Protection Services

Key Points

SYN Flood Attack

SYN Flood Attack

How SYN Flood Attacks Work

How to Protect Against SYN Floods

AWS Security Services Overview - Exam twisting questions

AWS Security Services Overview

AWS NAT Gateway vs. AWS NAT Instance

AWS NAT Gateway vs. AWS NAT Instance

Interface-Driven Development - IDD - Deep Dive

Interface-Driven Development - IDD

Interface-Driven Development - IDD is a Software development design approach that emphasis on using interfaces to define contracts or boundaries between different components of the system.

Key Concepts

Interface as a contract

Decoupling

Interface Proliferation

Difficulty in Testing

Loss of Cohesion

AWS Learning 001 - Amazon EC2 - 003 - Instance Purchase Options

Amazon EC2 Instance Purchase Options

Instance Purchasing Options in AWS EC2:

On-Demand Instances

Savings plan

Reserved Instances (RI)

Spot Instances

Dedicated Hosts

Dedicated Instances

Differences Between Dedicated Hosts and Dedicated Instances

Capacity Reservations

AWS Learning 001 - Amazon EC2 - 002 - Instance Types

Amazon EC2 Instance Types

Amazon EC2 Instances are categorized based on performance characteristics and appropriate use cases.The following are the instance types based on the performance

EC2 Instance Types and Server Purposes - Use Cases

General Purpose

Compute Optimized

Ideal for compute-bound applications that need high-performance processors.

Compute Optimized

Memory Optimized

Accelerated Computing

Storage Optimized

Nitro-based

Cloud Continuous Deployment (CD) Services Comparison

AWS Network Access Control Lists (NACLs) and Security Groups

Azure NAT Gateway Process

Cloud Continuous Integration (CI) Services Comparison

C# - out - Reference Programming - Deep dive

'out' - Reference Programming - Deep dive

Purpose

Examples

Output

Key Takeaways

C# - ref - Reference Programming - Deep dive

'ref' - Reference Programming - Deep dive

In C# using 'ref' keyword is indicating that the parameter is passed by reference rather than value, that means, any changes made to the parameter will be made available outside of the method.

The other purpose of using ref is, we can return multiple parameters from a method, this might be very useful in cases where we need multiple values to be evaluated in the caller function.We will see how this is happening!

Example 1: Basic implementation of 'ref'

int num = 10; Console.WriteLine($"Before method call: {num}"); ModifyValue(ref num); Console.WriteLine($"After method call: {num}"); // Output // Before method call: 10 // After method call: 20 } Calling method static void ModifyValue(ref int x) { x = x * 2; }

Example 2: Multiple 'ref' implementation

int result1 = 0, result2 = 0; CalculateValues(5, 3, ref result1, ref result2); Console.WriteLine($"Sum: {result1}, Difference: {result2}"); Calling method static void CalculateValues(int a, int b, ref int sum, ref int difference) { sum = a + b; difference = a - b; }

Example 3: Handling Reference Types

Example 3: Demonstrating String Behavior

Example 4: Using ref in string

`Interface-Driven Development - IDD` is a Software development design approach that emphasis on using interfaces to define contracts or boundaries between different components of the system.

`Amazon EC2 Instances` are categorized based on performance characteristics and appropriate use cases.
The following are the instance types `based on the performance`

Ideal for compute-bound applications that need `high-performance processors`.

The other purpose of using ref is, we can return multiple parameters from a method, this might be very useful in cases where we need multiple values to be evaluated in the caller function.

We will see how this is happening!

`int num = 10; Console.WriteLine($"Before method call: {num}"); ModifyValue(ref num); Console.WriteLine($"After method call: {num}"); // Output // Before method call: 10 // After method call: 20 }`
Calling method
`static void ModifyValue(ref int x) { x = x * 2; }`

`int result1 = 0, result2 = 0; CalculateValues(5, 3, ref result1, ref result2); Console.WriteLine($"Sum: {result1}, Difference: {result2}");`
Calling method
`static void CalculateValues(int a, int b, ref int sum, ref int difference) { sum = a + b; difference = a - b; }`

`int number = 1; Console.WriteLine($"Original Number: {number}"); IncrementRef(ref number, 5); Console.WriteLine($"Incremented Number: {number}");`
Calling method
`static void IncrementRef(ref int num, int limit) { if (num < limit) { num++; IncrementRef(ref num, limit); } }`