vault backup: 2025-04-15 15:19:41

2025-04-15 15:19:41 +03:30
parent 8336415d34
commit 587d0e32fc
1 changed files with 323 additions and 0 deletions
@@ -357,3 +357,326 @@ You are provided with a SQL script, that adds some sample data into the followin
 # Merge
 - [ ]  Create the feature/transportation-search branch based on develop
 # Additional Info
 ### 1. **Should I have an `IEntityService` and then `EntityService` for each of my entities?**
 Not necessarily **for _every_** entity — only if it **makes sense**.
 - The Application Layer should expose **use cases** — not just CRUD logic for each entity.
 - If an entity has business logic or interactions that need orchestration (e.g., validations, aggregations, calling repositories, etc.), then **yes**, create a service.
 - Otherwise, for basic operations, **directly using a repository (via a unit of work or interface)** from the use case handler might be fine.
 ### 2. **Is it OK to have services not related to a specific entity?**
 Absolutely, **yes**. In fact, that’s expected in a Clean Architecture setup.
 Examples:
 - A `ReportGenerationService` that combines bookings, customers, and payments.
 - A `TokenService` for authentication tokens.
 - A `CurrencyConversionService` that hits an external API.
 - A `NotificationService` that sends emails or SMS.
 👉 As long as these services **live in the Application Layer** and follow **dependency inversion** (i.e., they depend only on interfaces, not implementations), you’re doing great.
 ### 3. **Is it necessary to have an interface for each service?**
 ### 🔹 **What’s the Difference Between Services and Repositories?**
 | Aspect             | **Service**                                                            | **Repository**                                                  |
 | ------------------ | ---------------------------------------------------------------------- | --------------------------------------------------------------- |
 | **Layer**          | Application Layer                                                      | Domain Layer (interface), Infrastructure Layer (implementation) |
 | **Responsibility** | **Orchestrates business logic** / use cases                            | **Data access abstraction**                                     |
 | **Focus**          | Coordinates multiple domain/repo operations, validation, business flow | Fetching/storing data for a specific entity                     |
 | **Example**        | `PlaceOrderService`, `ReportService`                                   | `ICustomerRepository`, `IOrderRepository`                       |
 ### What does `init` mean?
 `init` is an **access modifier for properties** that allows you to **set a property only during object initialization**, **but not after**.
 ## Should I use `class` or `record` for DTOs in Clean Architecture?
 ### 🔵 Short answer:
 > **Use `record` for DTOs when possible** — it's clean, immutable by default, and semantically perfect for data transfer.
 ---
 ### 🔍 Why `record` is a great fit for DTOs
 | Feature                 | `record`          | `class`                      |
 | ----------------------- | ----------------- | ---------------------------- |
 | Immutable by default    | ✅ (with `init`)   | ❌ (need manual setup)        |
 | Value-based equality    | ✅                 | ❌ (ref-based by default)     |
 | Concise syntax          | ✅                 | ❌ (more boilerplate)         |
 | Use for data containers | ✅ (perfect fit)   | ✅ (but more verbose)         |
 | Custom behavior/logic   | ❌ (less suitable) | ✅ (better for rich behavior) |
 ### But when should you prefer `class`?
 Use `class` if your DTO or model:
 - Needs to be **mutable** after creation
 - Has to **interact with legacy APIs/libraries**
 - Needs **inheritance or polymorphism** (not well supported in `record`)
 - Has **rich behavior** (logic, methods, validation, etc.)
 > For example, in the Domain Layer (Entities, ValueObjects), you'll usually stick to **`class`** — because that's where behavior lives.
 ## RESTful APIs:
 https://aws.amazon.com/what-is/restful-api/#:~:text=RESTful%20API%20is%20an%20interface,applications%20to%20perform%20various%20tasks.
 ## What Conditions Make an API RESTful?
 ### Key Principles of REST:
 1. **Statelessness**:
    - Each API call must contain all the information the server needs to fulfill the request (no session state). Each request is independent.
 2. **Resource Identification**:
    - Resources (e.g., customers, orders) should be identified using URIs. Use nouns in URIs, not verbs.
 3. **HTTP Methods**:
    - Use standard HTTP methods to represent actions:
        - **GET**: Retrieve a resource.
        - **POST**: Create a new resource.
        - **PUT**: Update a resource entirely.
        - **PATCH**: Update a resource partially.
        - **DELETE**: Remove a resource.
 4. **Use of Standard Status Codes**:
    - Return appropriate HTTP status codes (e.g., `200 OK`, `201 Created`, `404 Not Found`, `500 Internal Server Error`).
 5. **HATEOAS**:
    - (Hypermedia as the Engine of Application State) - Provide links to related resources within the responses.
 ### Multiple GET Methods in One Controller:
 - **Yes, you can have multiple GET methods in one controller**. The key is to differentiate them based on routes and parameters.
 - For example:
 ```c#
 [ApiController] 
 [Route("api/[controller]")] 
 public class CustomerController : ControllerBase {     
 	[HttpGet("{id}")]     
 	public IActionResult GetCustomerById(int id) { /*...*/ }      
 	[HttpGet]     
 	public IActionResult GetAllCustomers() { /*...*/ }      
 	[HttpGet("{id}/orders")]     
 	public IActionResult GetCustomerOrders(int id) { /*...*/ } 
 }
 ```
 - **Routing**: ASP.NET Core uses route templates to differentiate these actions. The combination of route parameters, query strings, and action names can help separate the GET requests.
 ## List-like stuff in `C#`
 Absolutely, let’s go over the main “list-like” data types in C#. They all serve similar purposes—holding multiple items—but differ in functionality, performance, and use cases. Here’s a detailed breakdown:
 🔷 1. IEnumerable
 - Namespace: System.Collections.Generic
 - Most basic "list-like" abstraction.
 - Read-only (forward-only iteration).
 - You can use foreach on it.
 - Doesn’t support indexing (no .Count, no [i]).
 - Often used as the return type to expose a stream of data without giving full collection control.
 Example:
 ```csharp
 IEnumerable<int> numbers = GetNumbers(); // Lazy-loaded maybe
 foreach (var num in numbers)
    Console.WriteLine(num);
 ```
 💡 Ideal when:
 - You want to return a sequence without exposing modification.
 - You’re using LINQ chains.
 - You’re returning data from a database query.
 ---
 🔷 2. ICollection
 - Extends IEnumerable.
 - Adds Count and Add/Remove/Clear methods.
 - Still abstract—List and HashSet implement it.
 💡 Useful when:
 - You want to expose a collection that can be modified (e.g. Add or Remove).
 - You care about the Count.
 ---
 🔷 3. IList
 - Extends ICollection and IEnumerable.
 - Adds index access: list[0] etc.
 - Think of it like a mutable array with dynamic size.
 💡 Use when:
 - You want ordered collection with indexing.
 - You need to insert, remove, or replace items at specific positions.
 ---
 🔷 4. List
 - A concrete class (not interface).
 - Implements IList, ICollection, IEnumerable.
 - Backed by an array (auto-resizes).
 - Fast read and write.
 - Supports Add, Remove, Insert, IndexOf, etc.
 Example:
 ```csharp
 var list = new List<string>();
 list.Add("One");
 list.Add("Two");
 var second = list[1]; // "Two"
 ```
 💡 Go-to general purpose collection.
 ---
 🔷 5. IReadOnlyCollection & IReadOnlyList
 - IReadOnlyCollection: Just Count and IEnumerable.
 - IReadOnlyList: Adds indexing without modification.
 - Used to expose lists safely (read-only).
 💡 Used when:
 - You want to return a list, but prevent any changes.
 ---
 🔷 6. Array (T[])
 - Fixed-size.
 - Fastest for indexing.
 - Cannot change size.
 - Implements IList (via Array).
 Example:
 ```csharp
 int[] numbers = new int[5];
 numbers[0] = 42;
 ```
 💡 Great for performance-sensitive or fixed-size data.
 ---
 🔷 7. ObservableCollection
 - For WPF/Blazor/WinForms data-binding.
 - Notifies UI when items are added/removed.
 - Implements IList.
 💡 Use in UI apps when the view needs to react to collection changes.
 ---
 🔷 8. HashSet
 - Unordered, no duplicates.
 - Implements ICollection, not IList.
 - No index access.
 💡 Best for fast membership checking (contains x).
 ---
 🔷 Summary Table
 |Type|Indexing|Modifiable|Ordered|Duplicates|Use Case|
 |---|---|---|---|---|---|
 |IEnumerable|❌|❌|✔️|✔️|Basic read-only stream or LINQ chaining|
 |ICollection|❌|✔️|✔️|✔️|Expose modifiable group of items|
 |IList|✔️|✔️|✔️|✔️|Full-featured list abstraction|
 |List|✔️|✔️|✔️|✔️|Standard go-to collection|
 |IReadOnlyList|✔️|❌|✔️|✔️|Return data safely from service or repo|
 |Array (T[])|✔️|✔️|✔️|✔️|Fixed-size, performant indexing|
 |ObservableCollection|✔️|✔️|✔️|✔️|UI binding for collections|
 |HashSet|❌|✔️|❌|❌|Fast lookup, uniqueness enforcement|
 —
 If you tell me the scenario (e.g. search results, modifying a cart, populating a drop-down), I can recommend the best type for it. Want that?