Ahmed Fathy

If anyone interested to this book please comment and I will send it to you #Csharp #dotnet #technicalBooks

٤٦

٨٤ تعليق

My ongoing projects include ParaPal (direct payment gateway), EsLa (fire alarm security system), and FlashCard (English language learning). #inprogress #native #development #singlepage #dotnet #netcore #aspnet #flutter

٢

𝐑𝐨𝐚𝐝𝐦𝐚𝐩 𝐭𝐨 𝐁𝐞𝐜𝐨𝐦𝐢𝐧𝐠 𝐚 𝐒𝐮𝐜𝐜𝐞𝐬𝐬𝐟𝐮𝐥 .𝐍𝐄𝐓 𝐁𝐚𝐜𝐤𝐞𝐧𝐝 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐞𝐫 🛣️ If you're looking for a solid career as a .NET backend developer, here are the key steps to stand out in the field: 1 - 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 𝐅𝐮𝐧𝐝𝐚𝐦𝐞𝐧𝐭𝐚𝐥𝐬 𝐄𝐬𝐬𝐞𝐧𝐭𝐢𝐚𝐥 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬: Start with programming logic and foundational principles, such as: - Control structures and flow - Object-Oriented Programming (OOP) - Design Patterns - Data Structures and Algorithms (DSA) 2 - 𝐊𝐧𝐨𝐰𝐥𝐞𝐝𝐠𝐞 𝐨𝐟 𝐭𝐡𝐞 .𝐍𝐄𝐓 𝐄𝐧𝐯𝐢𝐫𝐨𝐧𝐦𝐞𝐧𝐭 𝐄𝐱𝐩𝐥𝐨𝐫𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 𝐭𝐡𝐞 .𝐍𝐄𝐓 𝐄𝐜𝐨𝐬𝐲𝐬𝐭𝐞𝐦: Deepen your understanding of the main components of .NET, including: - Common Language Runtime (CLR) and Base Class Library (BCL) - Memory management and garbage collection - Exception handling and asynchronous programming 3 - 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐃𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 𝐚𝐧𝐝 𝐅𝐫𝐨𝐧𝐭-𝐄𝐧𝐝 𝐈𝐧𝐭𝐞𝐠𝐫𝐚𝐭𝐢𝐨𝐧 𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐖𝐞𝐛 𝐒𝐨𝐥𝐮𝐭𝐢𝐨𝐧𝐬: Learn to build applications and integrate front-end technologies such as: - Angular, React, or Blazor - Development of RESTful APIs and middleware 4 - 𝐃𝐚𝐭𝐚 𝐀𝐜𝐜𝐞𝐬𝐬 𝐚𝐧𝐝 𝐌𝐚𝐧𝐢𝐩𝐮𝐥𝐚𝐭𝐢𝐨𝐧 𝐃𝐚𝐭𝐚𝐛𝐚𝐬𝐞 𝐈𝐧𝐭𝐞𝐫𝐚𝐜𝐭𝐢𝐨𝐧: Master the use of: - Entity Framework Core for ORM - LINQ for data queries 5 - 𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞𝐬 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐚𝐧𝐝 𝐂𝐥𝐨𝐮𝐝 𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐚𝐧𝐝 𝐌𝐚𝐧𝐚𝐠𝐢𝐧𝐠 𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞𝐬: Understand how to construct and manage microservices using: - Cloud services like Azure or AWS - Containers with Docker and orchestration with Kubernetes 6 - 𝐓𝐞𝐬𝐭𝐢𝐧𝐠 𝐚𝐧𝐝 𝐂𝐨𝐝𝐞 𝐕𝐚𝐥𝐢𝐝𝐚𝐭𝐢𝐨𝐧 𝐄𝐧𝐬𝐮𝐫𝐢𝐧𝐠 𝐐𝐮𝐚𝐥𝐢𝐭𝐲: Develop skills in: - Unit and integration testing with tools like xUnit, TUnit, or NUnit - Debugging and code analysis tools 7 - 𝐂𝐨𝐧𝐭𝐢𝐧𝐮𝐨𝐮𝐬 𝐈𝐧𝐭𝐞𝐠𝐫𝐚𝐭𝐢𝐨𝐧 𝐚𝐧𝐝 𝐃𝐞𝐯𝐎𝐩𝐬 𝐀𝐮𝐭𝐨𝐦𝐚𝐭𝐢𝐧𝐠 𝐏𝐫𝐨𝐜𝐞𝐬𝐬𝐞𝐬: Learn to integrate CI/CD into your workflow, including: - Pipelines with Azure DevOps and GitHub Actions 8 - 𝐂𝐨𝐦𝐦𝐮𝐧𝐢𝐭𝐲 𝐏𝐚𝐫𝐭𝐢𝐜𝐢𝐩𝐚𝐭𝐢𝐨𝐧 𝐚𝐧𝐝 𝐂𝐨𝐧𝐭𝐢𝐧𝐮𝐨𝐮𝐬 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐂𝐨𝐧𝐭𝐫𝐢𝐛𝐮𝐭𝐢𝐨𝐧 𝐚𝐧𝐝 𝐍𝐞𝐭𝐰𝐨𝐫𝐤𝐢𝐧𝐠: Engage with the developer community, stay updated, collaborate on open-source projects, and participate in events. 💪 𝐅𝐢𝐧𝐚𝐥 𝐓𝐢𝐩: The journey may be challenging, but passion for programming and a desire to learn will always make a difference. Which steps have you started or wish to explore? Share your thoughts and experiences in the comments! 👇 #CSharp #Backend #Development #Roadmap #Programming

١٣٨

٢٩ تعليق

Microservices using ASP.NET Core Online Training with Real-time Application Development This Microservices using ASP.NET Core Online Training Program is entirely industry-oriented, and the concepts mostly used in the industry will be explained in depth. Please find the Course Details below: Course: Microservices using ASP.NET Core Web API Date and Time: 1st August, 2024, 8 PM to 9.30 PM, IST Contact Mobile/WhatsApp Number: 91 7021801173 Duration: 2 Months Contact Email: [email protected] Course Details Link: https://lnkd.in/gZ4cRK36 Join Our Telegram Group and ask anything: https://lnkd.in/g8Rwhz89 Registration Link: https://lnkd.in/gGsYTwme The following concepts will be covered in depth. Please find the detailed Course Syllabus in the attached PDF. Chapter 1: Understanding Monolithic Architecture Chapter 2: Microservices Architecture Chapter 3: Handling Data in Microservices Chapter 4: API Gateway Pattern Chapter 5: Setup Microservice Based Application and Perform CRUD Operations Chapter 6: Build UI Service Chapter 7: Introduction to Containers and Docker Chapter 8: Developing Docker Custom Images using .NET Core Chapter 9: Docker Compose Chapter 10: Hosting Microservices using Docker Containers Chapter 11: Using Redis Cache in Microservices Chapter 12: Introduction to Web Sockets and Kafka Chapter 13: WebSocket Basics with .NET Core Chapter 14: Kafka Basics with .NET Core Chapter 15: Implementing Security for Microservices Chapter 16: Understanding OAuth2, OpenIdConnect, and Identity Chapter 17: Implementing the CQRS Pattern Chapter 18: Vertical/Clean Architecture Chapter 19: MassTransit Chapter 20: YARP Gateway Chapter 21: RabbitMQ with ASP.NET Core Web API Chapter 22: Handling Failures Chapter 23: Microservices Deployment in App Services Chapter 24: Monitoring and Observability Chapter 25: Performance Optimization Chapter 26: Advanced Topics in Microservices Chapter 27: Azure CI/CD Pipeline for .NET Core Web API

٢

#Understanding_the_Common_Language_Runtime(CLR) The Common Language Runtime (CLR) is the heart of the .NET framework, responsible for managing the execution of .NET programs. Here’s a look at how CLR functions: 1. #Compilation_and_Execution:- #Compilation: When you write code in C#, VB.NET, or any .NET language, it's compiled into Intermediate Language (IL), also known as MSIL (Microsoft Intermediate Language) or CIL (Common Intermediate Language). This IL is platform-independent and is not directly executable by the CPU. #Execution: At runtime, the IL code is compiled by the CLR's Just-In-Time (JIT) compiler into native machine code that the CPU can execute. This compilation happens on-demand and ensures that the code runs efficiently on the specific hardware. 2. #Memory_Management: #Garbage_Collection: CLR includes a garbage collector that automatically manages memory by reclaiming unused objects. This prevents memory leaks and helps maintain application stability and performance. #Memory_Allocation: CLR provides services for allocating and deallocating memory efficiently, optimizing memory usage throughout the application's lifecycle. 3. #Exception_Handling:- CLR provides robust mechanisms for handling exceptions that occur during program execution. This includes structured exception handling using try-catch-finally blocks, ensuring reliable error management and program stability. 4. #Security:- CLR enforces code access security policies, which restrict the actions that code can perform to protect the system and its resources. Security checks are performed during JIT compilation and at runtime, ensuring that code operates within defined security boundaries. 5. #Type_Safety_and_Verification: - Before JIT compilation, CLR performs type verification to ensure that IL code accesses only valid memory locations and adheres to type safety rules. This prevents common programming errors that could lead to crashes or security vulnerabilities. 6. #Interoperability: - CLR facilitates interoperability between .NET code and unmanaged code (such as C or C++), COM components, and other systems. It provides mechanisms like Platform Invocation Services (P/Invoke) and COM Interop to enable seamless integration. 7. #Execution_Environment: - CLR provides a managed execution environment where .NET applications run. It abstracts the underlying hardware and operating system, providing a consistent runtime environment across different platforms (Windows, Linux via .NET Core, etc.).

١

Why Implement API Versioning? It allows you to support different versions of your API simultaneously. It enables you to safely introduce new features or changes without disrupting existing users. Here is an example of using API Versioning in ASP.NET Core Web API: 1- Install the NuGet Package: dotnet add package: Microsoft.AspNetCore.Mvc.Versioning 2- Configure API Versioning: In the ConfigureServices method, add the following services.AddApiVersioning(options => { options.ReportApiVersions = true; // Reports supported API versions in response headers options.AssumeDefaultVersionWhenUnspecified = true; // Uses the default version if not specified options.DefaultApiVersion = new ApiVersion(1, 0); // Sets the default API version }); 3- Create Versioned Controllers: Copy your existing controller and add the ApiVersion attribute. Also, update the Route attribute to reflect the version, as shown in the snapshots. 4- Test the API Versioning by calling the two different versions of your API: Version 1.0: GET /api/v1/products Version 2.0: GET /api/v2/products

٦

As a former architect .. I find system designing and architecture in software world very interesting and challenging. A nice path to consider. #design #architecture #software #systems

٢

❓18 questions for Junior .NET developer interview (with answers)❓ Are you willing to join .NET developer Junior position? Or just want to start complicated training in .NET? Try to answer 10 most popular questions you may hear in the interview and check your answers in the first comment: 1. What is object-oriented programming? Describe its main principles. 2. What is the difference between managed and unmanaged code? 3. What is the difference between C and C#? 4. What is an object in the C# language? What is a program? 5. What is called a method in the C# language? 6. What is a structure in the C# language? 7. How does a garbage collector work in C#? What are the conditions for garbage collection? 8. What is an array? 9. What is recursion? 10. What are the types of design patterns? Can you provide examples of their usage? 11. What is REST API? Can you define it in your own words? 12. Can you provide an example of a SOLID principle violation? 13. Can you describe the best CI/CD pipeline you can imagine? 14. How would you address a growing technical debt? 15. What is multithreading and why do we need it? 16. When do you use asynchronous methods? 17. What is LINQ? 18. What are commonly used .NET collection types? Check the comments for answers. If you feel that you know more than half of these topics, try to apply to our part-time job with training opportunities in Turkiye by the link in the first comment.

٣٧

١ تعليق واحد

✨ 𝗞𝗲𝗿𝗻𝗲𝗹 𝗖𝗮𝗹𝗹 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗧𝗲𝘀𝘁 𝗶𝗻 .𝗡𝗘𝗧 8 ✨ . Inspired by Hussein Nasser's post, "How many kernel system calls do runtimes make?", I conducted a similar test for .NET. I replicated the C and Python code from his post and created a C# version to benchmark in .NET 8 on WSL2. . 💡And here is the result - • 𝗖: 46 system calls🔥 • 𝗣𝘆𝘁𝗵𝗼𝗻: 494 system calls • 𝗖#: 4735 system calls 😔😖🤯 . These findings highlight the vast performance differences across languages. While I was hoping to see C# outperform Python and Node, the result tells a different story! . 🛠 𝗖# 𝗰𝗼𝗱𝗲 𝘀𝗻𝗶𝗽𝗽𝗲𝘁: ```csharp string readText = File.ReadAllText("input.txt"); System.Console.WriteLine(readText); ``` . Thoughts? Have you tested similar scenarios across runtimes? I would love to hear your insights! . #dotnet #csharp #python #performance #programming #kernelcalls

١٩

١ تعليق واحد

#Multithreading #Parallel_Invoke #Prallel_For #Parallel_ForEach https://lnkd.in/dn8HQqub Source code is available on GitHub https://lnkd.in/dMZWHRbN Slides are available on https://lnkd.in/dAAu-J5H

٤

Monolithic vs Microservices Architecture – Choosing the Right Fit 🏛️ Monolithic vs Microservices Architecture – Which is Right for Your Project? In software development, the choice between Monolithic and Microservices Architecture can define a project’s scalability, maintainability, and performance. Let’s dive into the differences and understand when to choose each. 1️⃣ Monolithic Architecture * All-in-One: Monolithic applications are built as a single, unified unit. * Easier to Develop: Simple to start with and ideal for small-to-medium applications. * Single Codebase: Everything – frontend, backend, database interactions – is managed in one place. * Deployment: Entire application is deployed at once, making it easier but less flexible. 💡 Example: Traditional e-commerce websites where all modules (product catalog, cart, orders) are part of a single application. 2️⃣ Microservices Architecture * Decentralized Structure: Applications are divided into small, independent services that communicate over APIs. * Scalability: Each service can scale independently based on demand. * Flexibility: Teams can use different technologies for each service. * Deployment: Each service can be deployed, updated, or scaled separately, allowing continuous delivery. 💡 Example: Netflix – Different services manage streaming, billing, and recommendations separately. Pros & Cons 🔹 Monolithic Pros: Easier to develop and deploy, fewer network calls, simpler to manage initially. Cons: Harder to scale and maintain over time, difficult to make changes without affecting the whole system. 🔹 Microservices Pros: Flexibility in tech stack, independent scalability, and faster deployment cycles. Cons: Higher complexity, more difficult to manage inter-service communication, requires robust DevOps. 💡 Key Takeaway: Choose Monolithic for simpler projects that don’t require massive scaling. Choose Microservices for complex, large-scale applications where flexibility, scalability, and independent deployments are crucial. 💬 Let’s Discuss: What’s your preferred architecture style? Do you think microservices are always better for modern applications? Share your thoughts below! 👇 #SystemDesign #Microservices #Monolithic #SoftwareArchitecture #TechLeadership #Scalability #DevOps #SoftwareEngineering #TechCommunity #AppDevelopment

٩

١ تعليق واحد

🚀 Exploring the Power of .NET Microservices with RabbitMQ EventBus 🚀 I'm excited to share this architectural diagram showcasing how we leverage .NET Core Microservices and RabbitMQ for efficient message-driven communication! 🔹 Message Sender: Our Microservice (Web API) publishes events to the RabbitMQ server using the Event Bus API. 🔹 RabbitMQ Server: Acts as the messaging backbone, managing multiple queues (Queue A & Queue B) and ensuring reliable delivery of messages. 🔹 Message Receivers: Other Microservices (Web APIs) subscribe to the relevant queues, process the incoming messages, and interact with the databases (SQL). This setup provides: Scalability: Easily handle increased load by adding more microservices. Decoupling: Independent microservices improve maintainability and flexibility. Reliability: RabbitMQ ensures message delivery even in case of temporary failures. With this architecture, we ensure seamless communication and robust performance across our services. #Microservices #DotNetCore #RabbitMQ #EventBus #SoftwareArchitecture #TechInnovation

٦

١ تعليق واحد

.Http file included with API project in .NET 8 👏 .http files as they allow us to send HTTP requests directly from within Visual Studio. From .NET 8 the API project template includes one by default which I think is great to expose more devs to them.

٣

✨ Tracking Change in Data in ASP.Net core web API and Log it in Database

٥٨

𝐌𝐚𝐬𝐭𝐞𝐫𝐢𝐧𝐠 𝐅𝐥𝐮𝐞𝐧𝐭 𝐀𝐏𝐈 𝐢𝐧 𝐀𝐒𝐏.𝐍𝐄𝐓 𝐂𝐨𝐫𝐞: 𝐒𝐢𝐦𝐩𝐥𝐢𝐟𝐢𝐞𝐝 𝐂𝐨𝐧𝐟𝐢𝐠𝐮𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐟𝐨𝐫 𝐂𝐨𝐦𝐩𝐥𝐞𝐱 𝐃𝐚𝐭𝐚𝐛𝐚𝐬𝐞𝐬 As part of my experience, while implementing an ASP.NET Core project, I learned the power of Fluent API and how it can be used for complex database configurations. 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐅𝐥𝐮𝐞𝐧𝐭 𝐀𝐏𝐈? Fluent API is a way to configure your database in Entity Framework Core. It allows you to define database rules using code in the 𝐎𝐧𝐌𝐨𝐝𝐞𝐥𝐂𝐫𝐞𝐚𝐭𝐢𝐧𝐠 method of your 𝐃𝐛𝐂𝐨𝐧𝐭𝐞𝐱𝐭. 𝐖𝐡𝐞𝐧 𝐭𝐨 𝐔𝐬𝐞 𝐅𝐥𝐮𝐞𝐧𝐭 𝐀𝐏𝐈 𝐌𝐨𝐫𝐞 𝐅𝐥𝐞𝐱𝐢𝐛𝐢𝐥𝐢𝐭𝐲: 𝐅𝐥𝐮𝐞𝐧𝐭 𝐀𝐏𝐈 𝐨𝐟𝐟𝐞𝐫𝐬 𝐦𝐨𝐫𝐞 𝐟𝐥𝐞𝐱𝐢𝐛𝐢𝐥𝐢𝐭𝐲 𝐭𝐡𝐚𝐧 𝐃𝐚𝐭𝐚 𝐀𝐧𝐧𝐨𝐭𝐚𝐭𝐢𝐨𝐧𝐬. It's used for complex configurations that Data Annotations can’t handle. 𝐀𝐝𝐯𝐚𝐧𝐜𝐞𝐝 𝐑𝐞𝐥𝐚𝐭𝐢𝐨𝐧𝐬𝐡𝐢𝐩𝐬: Use Fluent API to set up complex relationships, such as many-to-many or composite keys. 𝐊𝐞𝐞𝐩𝐬 𝐌𝐨𝐝𝐞𝐥𝐬 𝐂𝐥𝐞𝐚𝐧: Fluent API separates configuration code from the model class, keeping the model focused on business logic. 𝐎𝐯𝐞𝐫𝐫𝐢𝐝𝐞𝐬 𝐃𝐚𝐭𝐚 𝐀𝐧𝐧𝐨𝐭𝐚𝐭𝐢𝐨𝐧𝐬: If you use both Data Annotations and Fluent API, Fluent API will override any conflicting configurations. 𝐂𝐮𝐬𝐭𝐨𝐦 𝐓𝐚𝐛𝐥𝐞 𝐚𝐧𝐝 𝐂𝐨𝐥𝐮𝐦𝐧 𝐍𝐚𝐦𝐞𝐬: You can use Fluent API to define custom table and column names that don’t follow EF Core's default conventions. 𝐈𝐧𝐝𝐞𝐱𝐞𝐬 𝐚𝐧𝐝 𝐂𝐨𝐧𝐬𝐭𝐫𝐚𝐢𝐧𝐭𝐬: Fluent API allows you to create indexes or apply unique constraints, which are not possible using Data Annotations alone. 𝐂𝐨𝐦𝐩𝐥𝐞𝐱 𝐂𝐨𝐧𝐟𝐢𝐠𝐮𝐫𝐚𝐭𝐢𝐨𝐧𝐬: Fluent API is great for configuring things like foreign keys with custom names, or setting cascade delete behaviors. 𝐖𝐨𝐫𝐤𝐬 𝐰𝐢𝐭𝐡 𝐌𝐢𝐠𝐫𝐚𝐭𝐢𝐨𝐧𝐬: Even if you use Fluent API, you still need to use migrations to apply the configurations to your database. 𝐋𝐚𝐫𝐠𝐞 𝐏𝐫𝐨𝐣𝐞𝐜𝐭𝐬: Fluent API is especially helpful in larger projects where database configurations are more complex and may change often. 𝐒𝐞𝐩𝐚𝐫𝐚𝐭𝐢𝐨𝐧 𝐨𝐟 𝐂𝐨𝐧𝐜𝐞𝐫𝐧𝐬: Fluent API allows better organization by keeping database configurations out of the model classes, leading to cleaner code. 𝐄𝐱𝐚𝐦𝐩𝐥𝐞: protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.Entity<Student>() .HasKey(s => s.StudentId); // Primary key modelBuilder.Entity<Student>() .Property(s => s.Name) .HasMaxLength(50) // Max length .IsRequired(); // Required field modelBuilder.Entity<Student>() .HasOne(s => s.Class) .WithMany(c => c.Students) .HasForeignKey(s => s.ClassId); // Foreign key }    Fluent API has given me more control over database configurations while keeping my code clean and organized. I’d love to hear your thoughts or experiences with Fluent API—how do you use it in your projects? #ASPNetCore #EntityFrameworkCore #FluentAPI 

١٢

١ تعليق واحد

ال Refactoring عملية مستمرة مش بس علشان نخلي الكود يشتغل، إنما علشان نحسّن الكود المكتوب كويس عشان يبقى أحسن. Refactoring المستمرة بتساعدنا نحسّن قابلية القراءة، نقلل التعقيد، ونحافظ على مستوى عالي من جودة الكود. لو دمجنا Refactoring في سير العمل اليومي بتاعنا، هنمنع تراكم الـ technical debt ونتأكد إن (codebase) تفضل قوية وقابلة للتوسع (scalable). مهم نلاحظ إن Refactoring مش إصلاح للأخطاء، ولا هوا تغيير الكود لحد ما يبقى خالي من الأخطاء. بالعكس، ده عن إعادة هيكلة الكود الحالي من غير ما نغيّر سلوكه الخارجي علشان نحسّن هيكله الداخلي. Refactoring is an ongoing process. It's not just about making code work, it's about enhancing well-written code to make it even better. Continuous refactoring helps us improve readability, reduce complexity, and maintain a high standard of code quality. By integrating refactoring into our regular development workflow, we prevent the buildup of technical debt and ensure our codebase remains robust and scalable. It's important to note that refactoring is not bug fixing, nor is it about changing code until it's free of errors. Instead, it's about restructuring existing code without altering its external behavior to improve its internal structure. “Driving is not about getting the car going in the right direction. Driving is about constantly paying attention, making a little correction this way, a little correction that way.” - Kent Beck (Extreme Programming, Embrace Change)

٤