🚀 What’s New in C# 12?

C# 12 includes:

• Primary Constructors
• Collection Expressions
• Interceptors (experimental)
• Interpolated String Handlers
• Default Lambda Parameters
• Static Abstract Members in Interfaces
• Required Members
• UTF-8 String Literals

We’ll explore each of these in detail with examples, comparisons, and real-world use cases.

Primary Constructors

Primary constructors allow you to declare constructor parameters directly in the class or struct definition, simplifying initialization and reducing boilerplate code.

Traditional Constructor (Pre-C# 12)

public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

Using Primary Constructor (C# 12)

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
}

In the C# 12 example, the constructor parameters name and age are declared directly in the class definition, and then assigned to the properties. This approach reduces redundancy and enhances readability.​

Benefits:

• Conciseness: Reduces the amount of code needed for property initialization.​
• Readability: Keeps constructor parameters and property assignments close together.​
• Maintainability: Simplifies updates to constructor parameters and property assignments.

Potential Pitfalls:

• Mutability: In non-record types, primary constructor parameters are mutable and do not automatically generate public properties.​
• Compatibility: Ensure your project targets .NET 8 or later to use primary constructors.

💡 Use Case:

• Great for services and models in ASP.NET Core where constructor injection is common.

⚠️ Gotchas:

• In non-record types, constructor parameters are mutable.
• Properties are not automatically generated, unlike in records.

📌 Pro Tip:

Add readonly to parameters or fields to ensure immutability:

public class Config(string name)
{
    public string Name { get; } = name;
}

Collection Expressions

C# 12 introduces collection expressions, enabling a concise syntax for initializing collections.​

Traditional Collection Initialization

var numbers = new List<int> { 1, 2, 3, 4, 5 };

Using Collection Expressions (C# 12)

var numbers = [1, 2, 3, 4, 5];

This new syntax simplifies collection initialization, making the code more readable and concise.​

Benefits:

• Simplicity: Reduces the verbosity of collection initialization.​
• Clarity: Enhances the readability of code involving collections.​

Compatibility:

• Collection expressions require .NET 8 or later.​

💡 Use Case:

• Perfect for initializing test data, mock objects, or quick list generation.
• Can be used in params and LINQ queries.

int Sum(params int[] values) => values.Sum();
Console.WriteLine(Sum([1, 2, 3])); // Outputs 6

📌 Pro Tip:

Use it for cleaner in-line function calls with array arguments.

Interceptors

Interceptors in C# 12 allow method call redirection, enabling optimized versions of methods to replace generalized ones. This feature is particularly useful in scenarios like logging, validation, or performance monitoring.​

Example:

Suppose you have a method Calculate that you want to intercept for logging purposes.​

[InterceptsLocation("Program.cs", line: 10, character: 5)]
public static int CalculateInterceptor()
{
    Console.WriteLine("Calculate method intercepted.");
    return 42; // Optimized result
}

In this example, calls to the Calculate Methods at the specified location are intercepted and redirected to CalculateInterceptor.​

Benefits:

• Optimization: Allows replacing generalized methods with optimized versions.​
• Flexibility: Enables cross-cutting concerns like logging or validation without modifying the original method.​

Caution:

• Experimental Feature: Interceptors are currently experimental and may be subject to change in future releases.​
• Complexity: Improper use of interceptors can lead to code that is difficult to understand and maintain.

💡 Use Case:

• AOP (aspect-oriented programming) scenarios like logging, validation, and performance tracking.
• Replace complex proxy/decorator patterns.

⚠️ Gotchas:

• Experimental in .NET 8 — subject to change.
• Debugging intercepted calls may be tricky.

Interpolated String Handlers

These handlers improve performance when using string interpolation, especially in logging scenarios where expensive formatting operations can be avoided.

✅ Example:

logger.LogDebug($"User ID: {user.Id}, Name: {user.Name}");

Behind the scenes, C# now allows conditional string building that only happens if the logging level is enabled.

💡 Benefit:

• Prevents unnecessary string allocations.
• Makes logging cleaner and faster.

📌 Pro Tip:

Use it with Microsoft.Extensions.Logging to avoid performance hits in production logs.

Default Lambda Parameters

You can now define default parameter values for lambdas, improving reusability and reducing code repetition.

✅ New in C# 12

Func<int, int> square = (int x = 2) => x * x;
Console.WriteLine(square()); // Outputs: 4

❌ Before C# 12

Func<int, int> square = (x) => x * x;
Console.WriteLine(square(2));

💡 Use Case:

• Default logic handlers
• Unit testing with optional parameters

Static Abstract Members in Interfaces

Now interfaces can declare static members, enabling generic math and strongly-typed factory methods.

✅ Example:

Interface IAddable<T>
{
    static abstract T Add(T a, T b);
}

struct Calculator : IAddable<int>
{
    public static int Add(int a, int b) => a + b;
}

💡 Use Case:

• Generic math libraries
• Consistent static API definitions

Required Members

Specify that certain properties must be initialized during object creation.

✅ Example:

public class Product
{
    public required string Name { get; set; }
    public decimal Price { get; set; }
}

var p = new Product { Name = "Laptop", Price = 899.99m }; // ✅

❌ Forgetting Required Property

var p = new Product { Price = 899.99m }; // ❌ Compile-time error

💡 Use Case:

• Enforces object validity
• Prevents uninitialized model data

UTF-8 String Literals

Now you can explicitly define UTF-8 string literals, improving performance and clarity in systems dealing with encoding.

✅ Example:

ReadOnlySpan<byte> greeting = "Hello"u8;

💡 Use Case:

• APIs that communicate over the network
• Interoperability with native code

Comparison with Previous Versions

.NET 8 vs .NET 9 Compatibility

Something like:

Real-World Use Case: ASP.NET Core DI + C# 12

public class HomeController(ILogger<HomeController> logger)
{
    public IActionResult Index()
    {
        logger.LogInformation("C# 12 rocks!");
        return View();
    }
}

No constructor body needed! Works seamlessly with .NET DI system.

Additional C# 12 Features You Shouldn’t Miss

Experimental Attribute

C# 12 introduces the ExperimentalAttribute, allowing developers to mark APIs as experimental. This attribute helps in signaling that certain features or APIs are not yet stable and may change in future releases.​

✅ Example:

[Experimental("EXP001")]
public void ExperimentalFeature()
{
    // Implementation
}

This feature is particularly useful for library authors who want to introduce new functionalities without committing to a stable API contract immediately.​

📏 Inline Arrays

Inline arrays are a new feature in C# 12 that allows the definition of fixed-size arrays within structs. This can lead to performance improvements by reducing heap allocations and improving data locality.​

✅ Example:

[System.Runtime.CompilerServices.InlineArray(5)]
public struct FixedArray
{
    private int _element0;
}

This feature is beneficial in scenarios where performance is critical, such as game development or high-performance computing.​

🔍 Pattern Matching Enhancements

C# 12 brings improvements to pattern matching, including extended property patterns and the ability to use patterns in more contexts. This allows for more expressive and concise code when working with complex data structures.

✅ Example:

if (person is { Age: > 18, Name: "Alice" })
{
    Console.WriteLine("Eligible");
}

These enhancements make it easier to write readable and maintainable code, especially when dealing with nested objects or complex conditions.

🧩 With Expressions for Records

With expressions allow for non-destructive mutation of records, enabling the creation of new record instances with modified properties. This feature promotes immutability and simplifies the process of updating record values.

✅ Example:

var person = new Person("Alice", 30);
var updatedPerson = person with { Age = 31 };

This is particularly useful in functional programming paradigms and scenarios where data immutability is desired.​

🔐 Sealed ToString() Methods in Records

C# 12 allows the ToString() method in records to be sealed, preventing further overrides in derived records. This ensures consistent string representations across different parts of an application.

✅ Example:

public record Person(string Name, int Age)
{
    public sealed override string ToString() => $"{Name}, {Age}";
}

Sealing the ToString() method can be beneficial when a standardized string output is required, such as in logging or serialization scenarios.​

🧵 Async Method Builders

C# 12 introduces the ability to define custom async method builders, providing more control over asynchronous method execution. This feature is advanced and primarily useful for library authors or scenarios requiring customized async behavior.

✅ Example:

public class CustomAsyncMethodBuilder
{
    public static CustomAsyncMethodBuilder Create() => new CustomAsyncMethodBuilder();
    public void SetResult() { /* Custom logic */ }
    // Other methods
}

public async CustomAsyncMethodBuilder MyAsyncMethod()
{
    await Task.Delay(1000);
}

Custom async method builders can be used to optimize performance or integrate with specific synchronization contexts.​

🛡️ Parameter Null Checking

C# 12 introduces a concise syntax for parameter null checking, reducing boilerplate code and improving code readability. By appending !! to a parameter, the compiler automatically inserts null checks.

✅ Example:

public void PrintName(string name!!)
{
    Console.WriteLine(name);
}

This feature helps in catching null reference exceptions early, enhancing the robustness of the code.​

🧩 Extension Everything

Building upon the concept of extension methods, C# 12 allows for the extension of properties, events, and even operators. This provides greater flexibility in augmenting existing types without modifying their source code.

✅ Example:

public static class StringExtensions
{
    public static int WordCount(this string str) => str.Split(' ').Length;
}

This feature promotes cleaner code and better separation of concerns by enabling modular extensions.​

Check out our other interesting article: Blazor vs Razor Pages

The post C# 12 Features You Should Be Using in 2025 appeared first on Dot Net Guide.

As we step into 2025 with the advancements in .NET 8, developers often face the dilemma: Blazor vs Razor Pages—which framework aligns best with their project needs?​

In this comprehensive guide, we’ll explore:

• Real-world performance benchmarks
• Migration strategies from MVC to Blazor or Razor Pages
• Pros and cons of each framework
• A decision flowchart
• SEO-optimized content and keywords
• FAQs for Google snippet ranking

What is Blazor?

Blazor is a powerful web UI framework that enables developers to build interactive web applications using C# instead of JavaScript. Built on .NET, Blazor promotes a full-stack C# development experience.

Blazor comes in two primary hosting models:

Blazor WebAssembly (WASM)

Blazor WebAssembly allows C# code to run directly in the browser using WebAssembly, delivering SPA-like experiences with rich interactivity.

• Client-side rendering
• Works offline
• Lighter server load
• Great for PWAs and dashboards

Example Use Case: SaaS dashboards, project management tools, design platforms (e.g., Figma clones)

Blazor Server

Blazor Server executes C# code on the server and syncs UI changes over SignalR in real time. It’s ideal for scenarios that require server trust or frequent real-time UI updates.

• Server-side logic with fast updates
• Smaller initial load compared to WASM
• Requires persistent connection (SignalR)
• No offline support

Example Use Case: Real-time inventory systems, live dashboards, internal admin panels

Blazor Component Example

<button @onclick="IncrementCount">Click me</button>
<p>Current count: @currentCount</p>

@code {
    private int currentCount = 0;
    private void IncrementCount() => currentCount++;
}

What Are Razor Pages?

Razor Pages is a page-focused web development model for ASP.NET Core that simplifies server-rendered web apps. It’s great for developers looking for fast load times and SEO optimization.

Key Features

• Fast page load times (~50KB HTML)
• SEO-friendly architecture
• Simple structure: .cshtml and .cshtml.cs files
• Built-in support for form handling and model binding
• Ideal For: Content-driven websites, CRUD applications, blogs, and marketing landing pages.

Razor Page Example

public class IndexModel : PageModel
{
    public string Message { get; set; }
    public void OnGet() => Message = "Loaded in 12ms!";
}

Blazor vs Razor Pages: Key Differences

Feature	Blazor WASM	Razor Pages
Initial Load	~2MB WASM download	~50KB HTML
SEO	Needs SSR	Fully SEO-optimized
Real-time UI	via SignalR	reload required
Offline Support	Supported	Not supported
Learning Curve	Moderate	Easy
Ideal Use Case	SPAs, Dashboards	Websites, Admin Panels

When to Use Blazor

• You need interactive UI components
• You want offline-first capabilities
• You’re building a modern, SPA-style web application
• You prefer full-stack development using C#

Best For:

• Progressive Web Apps (PWAs)
• Cross-platform line-of-business apps
• Dashboard-driven tools

When to Use Razor Pages

• Your application is content-heavy and SEO-focused
• You need fast initial page load times
• You’re building forms or CRUD-heavy apps
• You want a simple migration from MVC

Best For:

• Public-facing websites
• Blogs and marketing pages
• Government or healthcare portals

Decision Flowchart

.NET 8 Performance Benchmarks

Tested on: AWS t2.micro, ASP.NET Core 8.0

Key Insights:

• Razor Pages offer blazing fast response times with minimal payloads, ideal for SEO.
• Blazor WASM has a heavier load but shines in interactive applications post-load.
• Blazor Server provides a sweet spot for responsive UIs in controlled environments.

Migration Tips

From MVC to Razor Pages:

• Minimal learning curve for MVC developers
• PageModel class mimics MVC controller logic
• Retain Razor syntax with simplified routing

From MVC to Blazor:

• Start with Blazor Server for a smoother transition
• Leverage ComponentTagHelper to embed Blazor in Razor Pages
• Plan for JS interop if needed

Frequently Asked Questions (FAQ)

Final Verdict: Blazor vs Razor Pages

Choose Blazor if:

• You want a SPA-like experience with dynamic components
• Prefer using C# over JavaScript
• Need offline support or rich interactivity
• Want to reuse logic across client/server

Choose Razor Pages if:

• You care about fast performance and SEO
• Your app is content-focused or form-heavy
• You need to deliver results fast with minimal complexity
• You’re migrating from traditional ASP.NET MVC

Final Thoughts

Blazor and Razor Pages are both powerful tools in the .NET 8 ecosystem. Instead of choosing one over the other, consider a hybrid model where Razor Pages handle SEO and content delivery, while Blazor enhances interactivity. With careful planning, you can leverage the strengths of both for a modern, high-performing web app

The post Blazor vs Razor Pages in .NET 8: Choosing the Best Framework in 2025 appeared first on Dot Net Guide.

Whether you’re searching for Atom vs VSCode, VSCode vs Atom, or Atom versus Visual Studio Code, this guide covers everything you need to know. We’ll dive into their features, performance, and customization options.

What is a Source Code Editor?

A source code editor is a specialized tool designed for writing and editing code. Unlike traditional text editors, these tools come equipped with features like syntax highlighting, code completion, debugging, and plugin support, making them indispensable for developers. While some editors are standalone applications, others are part of Integrated Development Environments (IDEs) that offer additional tools for building and deploying software.

In this comparison, we’ll focus on Visual Studio Code and Atom, two editors that straddle the line between lightweight text editors and full-fledged IDEs. Both are highly customizable, extensible, and widely used in modern web and cloud application development.

Visual Studio Code vs Atom: An Overview

Before diving into the specifics, let’s briefly introduce both editors:

• Visual Studio Code (VS Code): Developed by Microsoft, VS Code is a free, open-source editor known for its speed, versatility, and robust feature set. It supports a wide range of programming languages, including JavaScript, TypeScript, and Node.js, and is available for Windows, macOS, and Linux. For a deeper dive into VS Code’s capabilities,
• Atom: Created by GitHub, Atom is another free, open-source editor often referred to as the “hackable text editor for the 21st century.” It’s highly customizable, with a strong emphasis on community-driven plugins and themes. Like VS Code, it’s available for Windows, macOS, and Linux.

Now, let’s explore the history of the Atom editor

Who Owns Atom Editor? (The Surprising Truth Developers Should Know)

If you’re wondering what happened to Atom, the once-beloved code editor, the ownership story reveals why it disappeared. Let me explain in simple terms:

The Short Answer:
Atom is technically owned by Microsoft through their GitHub acquisition, but it’s no longer actively developed.

The Full Timeline:

1. The GitHub Era (2011-2018)
   • Created by GitHub as an open-source alternative
   • Pioneered “hackable” editor concepts
   • Gained passionate following among web developers
2. The Microsoft Takeover (2018)
   • Microsoft acquired GitHub for $7.5B
   • Created awkward sibling rivalry with VS Code
   • Development slowed as resources shifted
3. The Sunset (2022-Present)
   • Officially discontinued December 2022
   • Still downloadable but unsupported
   • Most features absorbed into VS Code

Why This Matters for Developers:

• VS Code now dominates with 75%+ market share
• Microsoft consolidated their editor strategy
• Many Atom features live on in VS Code

Feature Comparison: VS Code vs Atom

To help you decide which editor is right for you, let’s compare Visual Studio Code and Atom across several key categories:

1. Setup and Installation

Both editors are straightforward to install, but there are subtle differences:

• VS Code: Offers a lightweight installer with more built-in features, reducing the need for additional plugins right out of the box.
• Atom: Has a larger installation size, which can impact performance, especially when multiple plugins are added.

For a step-by-step guide on installing and setting up VS Code, Please follow below steps.

Visual Studio Code Installation on Windows

 Step 1: Download the .exe package from the official website as shown below.

You can download the Visual Studio Code from their Official Website. Or search Visual Studio code on Google and click on first link

Step 2: Now run the executable file. As you run, you will see the below window.

Step 3: Select the option “I accept the agreement” and click on Next.

Step 4: Select the other tasks that you would like to perform from the below window.

Step 5: Click on Install from the following window.

Step 6: Wait for the installation to be completed.

Step 8: As the installation gets completed, you will land on the below window. Click on Finish button.

Step 9: As you click on finish, the Visual Studio Code gets launched.

Atom Installation On Windows

Step #1: Download the .exe package from the official website as shown below.

Step #2: As you run the downloaded file, the below window will appear.

Step #3: As installation is complete, the Atom editor window is launched.

2. Design and Customization

• Both editors feature clean, modern interfaces with support for dark and light themes.
• VS Code: Provides a more polished and professional look, with a focus on usability.
• Atom: Excels in customization, allowing users to create and apply their own themes and UI tweaks with ease.

3. Performance

• VS Code: Known for its speed and efficiency, even with multiple extensions enabled. Its performance is often praised by developers.
• Atom: While functional, Atom can become sluggish when handling large files or running numerous plugins due to its extension-heavy architecture.

Performance comparison: VS Code vs Atom.

4. Configuration

• VS Code: Uses a simple JSON file for configuration, recently enhanced with a Graphical User Interface (GUI) for easier customization.
• Atom: Relies heavily on a GUI for configuration, offering a more intuitive but sometimes less flexible setup.

5. User Experience

• VS Code: Offers a seamless experience with a rich set of built-in features, making it ideal for both beginners and experienced developers.
• Atom: Provides a good user experience but requires more effort to configure and extend to match VS Code’s out-of-the-box capabilities.

6. Core Features

• VS Code: Comes with powerful built-in tools like IntelliSense (code completion), debugging, Git integration, and Markdown preview.
• Atom: Relies more on plugins for core functionality, though it does include built-in Git integration.

Let’s have a glimpse of the features that Visual Studio Code and Atom offer. This indeed will help to decide which editor to use as per the requirement.

7. Plugins and Extensions

• VS Code: Has a vast library of extensions for adding language support, themes, and advanced features.
• Atom: Takes customization to the next level with a wide array of plugins, making it highly adaptable but potentially slower.

Check out this Introduction To Dot Net Framework to discover the concepts of the .NET framework.

8. Community and Support

• Both editors have large, active communities.
• VS Code: Backed by Microsoft, ensuring regular updates and strong support.
• Atom: Benefits from GitHub’s open-source community, fostering innovation and collaboration.

9. Source Control Integration

• Atom: As a GitHub product, it offers seamless Git integration, with visual indicators for uncommitted changes.
• VS Code: While it supports Git through extensions, it doesn’t quite match Atom’s native integration—though this may improve with Microsoft’s ownership of GitHub.

Additional Topics: Atom vs VSCode and Synonyms

When discussing Atom vs VSCode, it’s important to consider synonyms and related terms like VSCode vs Atom, Atom versus Visual Studio Code, and Atom compared to VSCode. These terms are often used interchangeably, but they all refer to the same comparison between these two popular code editors.

10. Ecosystem and Integration

• VS Code: Integrates seamlessly with Microsoft’s ecosystem, including Azure, GitHub, and other Microsoft services. It also supports a wide range of third-party tools and extensions.
• Atom: Being a GitHub product, it integrates naturally with GitHub repositories, making it a favorite among open-source developers.

11. Learning Curve

• VS Code: Easier for beginners due to its intuitive interface and extensive documentation.
• Atom: Slightly steeper learning curve due to its reliance on plugins and customization.

12. Updates and Maintenance

• VS Code: Receives frequent updates from Microsoft, ensuring it stays current with the latest development trends.
• Atom: Updates are less frequent, but the open-source community ensures it remains relevant.

Frequently Asked Questions

1. Why is VS Code faster than Atom?
   VS Code has more built-in features, whereas Atom relies on plugins for similar functionality, which can slow it down.
2. Is VS Code based on Atom?
   No, but both editors use the Electron framework. VS Code includes additional features like IntelliSense that set it apart.
3. Is Atom owned by Microsoft?
   Atom is developed by GitHub, which is owned by Microsoft.
4. What’s the difference between VS Code and Visual Studio?
   VS Code is a lightweight text editor, while Visual Studio is a full-fledged IDE with advanced tools for debugging, compiling, and more.

Conclusion

Both Visual Studio Code and Atom are excellent choices for developers, each with its own strengths and weaknesses. VS Code shines with its performance, built-in features, and polished user experience, making it a favorite for many. Atom, on the other hand, offers unparalleled customization and flexibility, appealing to those who enjoy tailoring their tools to their exact needs.

If you’re new to coding, either editor will serve you well. However, if performance and ease of use are your priorities, VS Code is the better choice. For those who value customization and don’t mind a bit of setup, Atom is a strong contender.

Ultimately, the best way to decide is to try both editors and see which one aligns with your workflow and preferences. Happy coding!

The post Visual Studio Code Vs Atom: The Ultimate Comparison appeared first on Dot Net Guide.

Anime fans worldwide rely on platforms like Gogoanime to stream their favorite shows. However, with frequent shutdowns and legal concerns, many users search for reliable Gogoanime alternatives. In this guide, we’ll explore:

• Safety tips to avoid malware and scams
• What Gogoanime offers (and its risks)
• 10+ best free anime sites (legal & pirated)
• Key features like dub/sub options, library size, and ad-free experiences

Gogoanime has become a household name among anime enthusiasts, offering a vast library of anime series, movies, and OVAs for free. With its user-friendly interface and regular updates, it’s no wonder that millions of fans flock to the site to watch their favorite shows. However, the platform’s legality and ethical implications have sparked debates within the anime community.

What is Gogoanime?

Gogoanime is one of the most searched free anime streaming websites globally. It offers a vast library of anime shows, movies, and OVAs with subbed and dubbed content. With fast updates and zero registration, it’s a go-to choice for millions of fans.

However, Gogoanime operates illegally, hosting copyrighted anime without licenses. This puts users at risk of malware, legal trouble, and constant domain changes.

Gogoanime Pros:

• 10,000+ anime titles
• Daily updates with latest episodes
• No signup needed
• Both dubbed and subbed content

Gogoanime Cons:

• Unstable domains (frequent shutdowns)
• Legal risks and lack of licenses
• Aggressive pop-up ads and potential malware
• Poor app experience

A good internet connection is all you need to watch new and classic anime in high-definition on this platform. However, there is a massive caveat for Gogoanime. It isn’t exactly legitimate. Gogo Anime has no license or permission to stream the shows or movies it harbors in its library. Thankfully, there are legitimate alternatives to GOGO Anime where you can legally and safely stream Anime content

 Visit Gogoanime Website

In this article, I aim to highlight some of the best anime streaming services available online while also addressing the concerns surrounding platforms like GOGO Anime. But before we delve into the details, let’s start with a quick overview of what anime is all about.

What is Anime?

For those new to the world of anime, it refers to animated content originating from Japan. To be classified as anime, the creative and production teams behind it must be primarily Japanese. Historically, anime gained its initial popularity during the 1960s and 1970s, laying the foundation for the global phenomenon it is today.

Anime’s unique appeal lies in its distinctive art style, rich storytelling, and exploration of complex themes. These elements set it apart from traditional Western cartoons, making it a captivating medium for audiences worldwide. My fascination with anime began in the late 90s and early 2000s, when it was still a niche genre in the West. However, thanks to advancements in digital technology and globalization, anime has since exploded in popularity.

Today, streaming services have made it easier than ever to access anime. But with its growing ubiquity comes a new challenge: finding legitimate sources to enjoy it. This is a significant issue for anime fans in the West. The limited availability of legal streaming options has driven many to platforms like GOGO Anime, which operate in a legal gray area. This explains why such sites have become so popular, despite their questionable legitimacy.

Why Gogoanime Changes Its Domains Frequently

One of the most puzzling aspects of Gogoanime is its frequent domain changes. This is primarily due to the platform’s legal gray area. Since Gogoanime hosts anime content without proper licensing, it often faces takedown requests and legal pressure. To avoid being shut down permanently, the site frequently switches domains, making it harder for authorities to track and block it.

While this allows the site to stay operational, it also creates inconvenience for users, who must constantly search for the latest working domain.

Pros of Using Gogo anime

Gogoanime’s biggest advantage is its free access to anime. Unlike subscription-based platforms, Gogoanime doesn’t charge users a dime. It also offers a wide variety of content, catering to fans of all genres. The platform’s convenience and lack of account requirements make it an attractive option for casual viewers.

Cons of Using Gogoanime

Despite its benefits, Gogoanime has its drawbacks. The platform’s unauthorized distribution of anime content harms creators and the industry. Users also face risks like pop-up ads, malware, and inconsistent video quality. Furthermore, the lack of official support means that broken links or missing episodes are common issues.

Gogoanime on App Store

Gogoanime offers both mobile and desktop applications, which function similarly to its website. The app provides access to a vast library of anime content, including subbed and dubbed versions of popular shows and movies. However, based on user reviews, the app appears to have significant issues. Many users have reported that it is buggy, unresponsive, and overall unreliable.

Despite the website’s popularity, the app has only around 50 downloads on the app store, indicating that it hasn’t gained much traction. While I haven’t personally used the app, the feedback from users suggests it falls short of expectations compared to the web version.

Is Gogoanime Safe or Legal?

No. Gogoanime is not safe or legal. Watching anime on unlicensed platforms may lead to:

• Malware and adware infections
• Poor streaming experience
• Legal consequences in certain regions

To enjoy anime legally and support the industry, it’s best to use licensed anime streaming platforms.

As mentioned earlier, Gogoanime operates without the proper licenses to host the anime content in its library. Streaming or downloading from such platforms may infringe on intellectual property rights, potentially exposing users to legal risks in the future. While some frequent users praise Gogoanime for being ad-free and free of intrusive pop-ups, this doesn’t mean the platform is entirely safe. Websites like these can still expose your device to harmful viruses and malware.

Additionally, Gogoanime often suffers from long and unexpected downtimes, making it unreliable for a seamless viewing experience. Given these drawbacks, I strongly recommend opting for safe and legitimate platforms to watch anime. There are several excellent, licensed streaming services available that provide high-quality content while supporting the anime industry.

Top 15 Best Legal Gogoanime Alternatives (2025)

For those seeking legal and safe alternatives, platforms like Netflix, Crunchyroll, and Funimation offer extensive anime libraries. These services not only provide high-quality streaming but also support the anime industry by compensating creators and licensors.

#1) Netflix

Netflix is a top choice for anime enthusiasts in the United States, thanks to its extensive and impressive anime library. The platform has gone the extra mile by remastering classic series, enhancing their picture quality for a better viewing experience. What’s more, Netflix simulcasts new episodes shortly after they air in Japan, ensuring fans stay up-to-date with their favorite shows. For those who crave premium quality, many of these titles are available in stunning 4K resolution.

One of Netflix’s standout features is its seamless streaming, with no buffering or downtime to interrupt your binge-watching sessions. It’s also a pioneer in the streaming world, being one of the few platforms investing in original anime productions. Beyond anime, Netflix offers a diverse collection of shows and movies from across the globe, making its subscription fee a worthwhile investment for entertainment lovers.

Netflix Plans and Pricing:

1. Standard with Ads:
   1. Price: $6.99/month
   1. Features:
      1. Access to most Netflix content with occasional ads.
      1. Stream in Full HD (1080p).
      1. Watch on 2 supported devices at a time.
2. Standard (No Ads):
   1. Price: $15.49/month
   1. Features:
      1. Ad-free streaming.
      1. Full HD (1080p) quality.
      1. Watch on 2 devices simultaneously.
      1. Option to download content on 2 devices.
3. Premium:
   1. Price: $22.99/month
   1. Features:
      1. Ad-free streaming.
      1. Ultra HD (4K) and HDR quality.
      1. Watch on 4 devices at the same time.
      1. Option to download content on 6 devices.

#2) Crunchyroll

Crunchyroll stands out as one of the most popular anime streaming platforms, not only in the USA but across the globe. With its recent acquisition of Funimation, the platform is set to expand its already massive library, making it an even more dominant force in the anime world.

What truly sets Crunchyroll apart is its unwavering focus on anime. It boasts one of the largest and most diverse collections of anime content worldwide, a feat no other platform can match. For just $7.99 per month, subscribers gain access to high-definition, ad-free streaming, with new episodes available shortly after they air in Japan. Additionally, Crunchyroll offers the convenience of offline viewing, making it a top choice for anime fans everywhere.

Crunchyroll Plans and Pricing:

1. Fan Plan:
   • Price: $7.99/month
   • Features:
     • Ad-free streaming.
     • Access to the entire Crunchyroll library, including simulcasts (episodes available shortly after they air in Japan).
     • High-definition (HD) video quality.
     • Offline viewing (download episodes on mobile devices).
2. Mega Fan Plan:
   • Price: $9.99/month
   • Features:
     • All benefits of the Fan Plan.
     • Stream on up to 4 devices simultaneously.
     • Discounts on the Crunchyroll store.
     • Exclusive access to special events and promotions.
3. Ultimate Fan Plan:
   • Price: $14.99/month
   • Features:
     • All benefits of the Mega Fan Plan.
     • Stream on up to 6 devices simultaneously.
     • Additional store discounts (e.g., 15% off).
     • Exclusive swag (e.g., annual gift).

Free Trial:

• Crunchyroll offers a 14-day free trial for new subscribers to test out the premium features. This trial is available for all paid plans (Fan, Mega Fan, and Ultimate Fan).

Source Verification:

You can verify this information directly on Crunchyroll’s official website:
Crunchyroll Plans and Pricing

#3) Hulu

Similar to Netflix, Hulu features a wide variety of anime content as part of its subscription offerings. The platform provides access to a mix of currently airing series and timeless classics. Although its anime library may not be as extensive as Crunchyroll’s or Netflix’s, Hulu still boasts a selection of critically acclaimed titles that make it a compelling option for anime fans.

Hulu Plans and Pricing :

1. Hulu (With Ads):
   1. Price: $7.99/month
   1. Features:
      1. Access to Hulu’s entire streaming library, including anime, TV shows, movies, and Hulu Originals.
      1. Includes ads during streaming.
2. Hulu (No Ads):
   1. Price: $17.99/month
   1. Features:
      1. Ad-free streaming for most content (some shows may still have ads due to licensing restrictions).
      1. Access to the same library as the ad-supported plan.

Hulu Website

#4) Amazon Prime

Amazon Prime stands as the second-largest streaming service in the US, trailing only behind Netflix. Naturally, it offers a selection of popular anime titles as part of its extensive library. The platform provides a diverse mix of licensed anime movies and TV shows, along with exclusive titles and simulcasts. Additionally, users have the option to rent or purchase digital anime content that isn’t included in the Prime membership.

1. Standalone Prime Video Plan:
   1. Price: $8.99/month
   1. Features:
      1. Access to Prime Video’s library of movies, TV shows, and exclusive content (including anime).
      1. Does not include other Amazon Prime benefits like free shipping, Prime Music, or Prime Reading.
2. Amazon Prime Membership:
   1. Price: 14.99/monthor14.99/monthor139/year
      • Features:
        • Includes Prime Video access.Additional benefits like free two-day shipping, Prime Music, Prime Reading, and more.
      Amazon Prime Website

#5) RetroCrush

If you’re a fan of vintage anime, RetroCrush is a platform you’ll absolutely love. It boasts an extensive library of critically acclaimed anime from the 1970s, 1980s, and 1990s, all carefully remastered by the RetroCrush team to enhance both picture and sound quality. The platform’s sleek and well-organized user interface makes navigation a breeze.

While many of these classic titles are behind a paywall, RetroCrush also offers a selection of anime that you can stream for free.

RetroCrush Pricing

1. Free Plan:
   1. Price: Free
   1. Features:
      1. Access to a selection of classic anime titles.
      1. Ad-supported streaming.
2. Premium Monthly Plan:
   1. Price: $4.99/month
   1. Features:
      1. Ad-free streaming.
      1. Access to the full library of remastered vintage anime.
3. Premium Annual Plan:
   1. Price: $49.99/year

#6) Funimation

Funimation was a leading anime streaming platform known for its high-quality English dubs and vast library of titles like Dragon Ball Z, My Hero Academia, and Demon Slayer. It offered simulcasts, exclusive content, and a user-friendly interface, making it a favorite among fans. In 2021, Funimation merged with Crunchyroll under Sony, and by 2022, its content was fully integrated into Crunchyroll.

While Funimation no longer operates as a standalone service, its legacy lives on through Crunchyroll, which now offers an even larger library of anime, including Funimation’s beloved dubs and exclusives. By subscribing to Crunchyroll, fans can enjoy ad-free, high-definition streaming while supporting the anime industry.

#7) HiDive 

HiDive is a premium anime streaming platform that offers a diverse library of both classic and contemporary anime. Known for its curated selection, HiDive features exclusive titles, simulcasts, and a mix of subbed and dubbed content. With affordable subscription plans and a user-friendly interface, it’s a great choice for anime fans looking for high-quality, legal streaming options. Whether you’re into action-packed shonen, heartfelt slice-of-life, or niche genres, HiDive has something for everyone.

Pricing Details

• Monthly Plan: $4.99 per month.
• Annual Plan: 47.99peryear(equivalenttoabout47.99peryear(equivalenttoabout3.99 per month, offering a 20% discount compared to the monthly plan). HiDive’s affordable pricing, combined with its curated selection, makes it a standout option for anime enthusiasts who want a legal and budget-friendly streaming service.
• Official Website: HiDive

#8) AnimeLab

AnimeLab is a leading anime streaming service tailored for fans in Australia and New Zealand. It offers a vast library of anime, including popular series, movies, and simulcasts straight from Japan. With a mix of subbed and dubbed content, AnimeLab ensures that fans can enjoy their favorite shows in their preferred format. The platform is known for its user-friendly interface, high-quality streaming, and exclusive access to some of the biggest anime titles.

Pricing Details

• Free Plan: Access to a limited selection of anime with ads.
• Premium Plan:
  • Monthly Subscription: $7.95 AUD per month.
  • Annual Subscription: 79.95AUDperyear(equivalenttoabout79.95AUDperyear(equivalenttoabout6.66 AUD per month, offering a 16% discount compared to the monthly plan). AnimeLab’s premium plan unlocks ad-free streaming, early access to new episodes, and the entire anime library, making it a fantastic value for dedicated fans.

#9) Aniwatch (formerly Zoro.to) – Best Free UI

• Library: 5,000+ titles (dub/sub)
• Features:
  • Zero ads (rare for free sites)
  • Community reviews and ratings
• Downside: Recently shut down; try AniWave (its successor)

Keyword Tip: A top “best anime sites free” option before shutdown.

#10) 9anime (Now AniWave) – Best for Dubs

• Library: 8,000+ anime (best-organized categories)
• Features:
  • Filter by genre, year, popularity
  • Active community (request missing shows)

Note: Use an ad blocker—pop-ups are common.9anime (Now AniWave) – Best for Dubs

• Library: 8,000+ anime (best-organized categories)
• Features:
  • Filter by genre, year, popularity
  • Active community (request missing shows)

Note: Use an ad blocker—pop-ups are common.

#11) Pluto TV

• 100% free streaming with live anime channels
• No registration required
• Available in select regions

#12) Tubi TV

• Free streaming with ads
• Broad anime library including classics and new releases
• Kid-safe content mode

#13) VRV

• Bundle of Crunchyroll, HIDIVE, and more
• Best for anime and geek culture fans

#14) Bilibili (Region-Specific)

• Offers exclusive anime with interactive subtitles
• Popular in Southeast Asia and China

#15) YouTube (Official Channels)

• Channels like Muse Asia, Ani-One offer free legal anime
• Available in many regions with minimal ads

Comparison of Top Anime Streaming Platforms

Platform	Free Option	Subbed	Dubbed	Simulcasts	Unique Features
Netflix					Originals, 4K, Global Reach
Crunchyroll	(with ads)				Largest library, Fast Simulcasts
Funimation					Best for English Dubbed
HiDive					Niche titles, uncensored
Amazon Prime	(included)				Prime exclusive anime
Hulu	(with ads)				Mix of anime + Western shows
Tubi					Completely free, kid mode
RetroCrush					Nostalgic anime classics
Pluto TV					Live anime channels, no login needed
YouTube					Muse Asia & Ani-One official content
VRV					Bundled streaming, Crunchyroll + more

How to Choose the Right Anime Site?

Ask these questions:

1. “Do I care about legality?” → Use Crunchyroll/Tubi.
2. “Do I need dubs?” → Try AniWave or Funimation.
3. “Is speed important?” → Avoid ad-heavy sites like KissAnime.

Safety Tips for Free Anime Sites

To avoid malware when you watch anime online:

• Use a VPN (e.g., NordVPN) to hide IP from ISPs.
• Install uBlock Origin to block malicious ads.
• Never download .exe files from streaming sites.

Legal Risks of Using Gogoanime

• DMCA notices: ISPs may throttle your connection.
• Malware infections: 32% of pirated sites host malicious scripts (source).

Better Option: Use free trials of legal services (e.g., Crunchyroll’s 14-day trial).

Final Verdict: Best Gogoanime Alternatives

For most users, we recommend:

• Best Legal Option: Crunchyroll
• Best Free Alternative: AniWave (if you accept risks)
• Best for Dubs: Funimation

FAQs About Gogoanime

Q: Is Gogoanime down?
A: Its domains change often—check Gogoanime. news for updates.

Q: What’s the safest free anime site?
A: Tubi TV (legal) or Aniwatch (low ads).

How to Choose the Right Anime Site?

Ask these questions:

1. “Do I care about legality?” → Use Crunchyroll/Tubi.
2. “Do I need dubs?” → Try AniWave or Funimation.
3. “Is speed important?” → Avoid ad-heavy sites like KissAnime.

Safety Tips for Free Anime Sites

To avoid malware when you watch anime online:

• Use a VPN (e.g., NordVPN) to hide IP from ISPs.
• Install uBlock Origin to block malicious ads.
• Never download .exe files from streaming sites.

Legal Risks of Using Gogoanime

• DMCA notices: ISPs may throttle your connection.
• Malware infections: 32% of pirated sites host malicious scripts (source).

Better Option: Use free trials of legal services (e.g., Crunchyroll’s 14-day trial).

FAQs About Gogoanime

How to Access Gogoanime Safely in 2025 (3 Steps)

1. Install a VPN (NordVPN or Surfshark recommended)
2. Enable ad-blocking (uBlock Origin works best)
3. Use mirror sites (Updated monthly list here)

Conclusion

Anime has seen an incredible rise in popularity across the West, fueled by the wide array of online streaming services. While it might be tempting to use platforms like Gogoanime, it’s important to consider the ethical implications. As anime fans, we have a responsibility to support the talented artists and creators behind these amazing shows and movies by choosing legitimate streaming sources.

Fortunately, there are far better ways to enjoy anime online. Platforms like Netflix and Crunchyroll offer high-quality streaming with crisp picture quality and accurate subtitles, ensuring a premium viewing experience. The platforms I’ve mentioned above are excellent alternatives to Gogoanime, providing access to both classic and contemporary anime that will delight any fan.

I encourage you to give these services a try. As a lifelong anime enthusiast, I’ve had nothing but positive experiences with these platforms, and I’m confident you’ll enjoy them just as much.

Ready to Stream?

Now that you know the best Gogoanime alternatives, bookmark this page for future updates. Share your favorite anime site in the comments!

The post Gogoanime Alternatives (2025) | Best Legal Anime Sites appeared first on Dot Net Guide.

Now in this UIPath tutorial, we will see the below topics.

Tutorial 1: My First Sequence workflow Project – Display welcome message.

Tutorial 2: Accept Input from a user.

Tutorial 3: Use If condition and variables in the process.

Tutorial 4: Variables introduction (String) & Use of Substring function.

Tutorial 5: Variables introduction (Integer)

Tutorial 6: Variables introduction (Boolean)

Tutorial 7: Introduction to flowchart workflow

Tutorial 8: Introduction to State Machine

UiPath Tutorial 1:

Display “Hi welcome to my first Project”

Step 1: Create a new blank process

     Add Process Name and Description.

Step 2: On Design Tab ->In Main.xaml: Add workflow type

• Sequence Chart-Used for the action which need to perform one after other.
• Flow chart –Used to create complex business process as it allows us to do multiple branching of logical operators.
• State machine
• Global handler

Step 3: On Activity: add message box, click, read excel , send email etc.

Select Sequence -> Select Message Box-> add message “Hi welcome to my first project”

Step 4: Debug-> Run File: see the result.

UiPath Tutorial 2:

Display “Hi Noah Welcome to my first Project”

1. Continue with the first tutorial: add activity –Input Dialog

-Add Input Label and Dialog Title.

• Create Variable ‘Name’ and Variable Type as String.
• Use that Variable in Message Box, as below

   “Hi, “+ Name +” welcome to my first project”

• Input Dialog ->Propertise ->Output->add variable ‘Name’

• Debug->Run File

UiPath Tutorial 3:

Variable-Year (e.g. 2021,2022 etc.)

Condition: Check if the year is Leap year or not

If the Year is leap year (Condition is True)-Display Message-“The year is leap year”.

If the Year is not leap year (Condition is False)-Display Message-“The year is leap year”.

Steps 1:

Create New Blank Process.

On Design tab: Click On Main.xaml .

On Activity /tab: Select Sequence Workflow.

Steps 2:

Create Variable ‘Year’ select Variable Type and Default value.

Step 3: Add Input Dialog box ->add Dialog Title as “Enter the year“and  Input Label as “Year Value”.

Add If Activity :

Step 4: Add If Condition for leap year

Year Mod 4=0  

Step 5: Add message box activity for then and else condition. Add Text as below

Step 6:Debug File->Run File

Enter Year Value as 2020 (Leap Year)

 Step 7 :Debug File->Run File

Enter Year Value as 2021(Not Leap Year)

UiPath Tutorial 4: Text/String Variable- Substring variable project

• Take User Name as User Input –Input Dialog
• Display the first three letters of the user name in Message Box
• Display User name in message box – Message Box
• “The user name is  “ + Username

Steps to follow:

-Create New Processes->On Design tab->On Main.xaml->Add Sequence workflow->add Activity Input Dialog box

-Enter Dialog title and Input Label

-Create two String Variables- UserName and NewName for substring

-Add Assign activity -for display the three letters of the user name

Index-0 and length=3 assign the Index and length value  in Substring

         NewName = Username.substring(0,3)

-Add Message Box Activity

         “The First three letters of Usename is ” +NewName

-Add Message Box Activity

            “The Username is ”  + UserName

UiPath Tutorial 5: Number Variable/Integer Variable/Int32 Variable –Used to store Numeric Information

Display User –John and display total marks

-Create 3 Variable for Subject like MarksInMath, MarksInEng, MarksInSS and TotalMarks

-Create 1 variable for Student Name like StudName

-Take User input for marks obtained in Math and assign the value to Variable –MarksInMath

-Take User input for marks obtained in English and assign the value to Variable – MarksInEng

-Take User input for marks obtained in Social Science and assign the value to Variable – MarksInSS

-Add Total Marks and Assign to New Variable to variable -TotalMarks

TotalMarks= MarksInMath+MarksInEng+MarksInSS

-Display Total Marks in Message Box.

StudName + ” total marks is = ”  + TotalMarks.ToString

Note: Add Variable as Output Result for each Input dialog box Properties

UiPath Tutorial 6: Boolean Variable – True/False

Variable-Year (e.g. 2021, 2022 etc.) , BooleanVar – Boolean Variable  

Condition: Check if the year is Leap year or not

If the Year is leap year (Condition is True)-Display Message-“The year is leap year”.

If the Year is not leap year (Condition is False)-Display Message-“The year is leap year”.

Steps 1:

Create New Blank Process.

On Design tab: Click On Main.xaml .

On Activity /tab: Select Sequence Workflow.

Steps 2:

Create Variable ‘Year’ select Variable Type as Int32 and ‘BooleanVar’ asBoolean variable.

Step 3: Add Input Dialog box ->add Dialog Title as “Enter the year“  and Input Label as “Year Value”

Step 4: Add If Condition for leap year

Year Mod 4=0 

Step 5: If the condition is True then:

• Assign Activity -> Add

                    BooleanVar=True

• Add Message Box Activity and to Display message for e.g  “True Year 2020 is leap year”

Add message as below:

BooleanVar.ToString  + ” Year ”  +  Year.ToString  +  ” is a leap year”

Note: In message box only String values can be display here we have to display Boolean and Integer variable so have to use convert to string function.

Step 6: : If the condition is False then:

Add Message Box Activity and to Display message for e.g  “True Year 2021 is not  leap year”

Add message as below:

BooleanVar.ToString  + ” Year  ” + Year.ToString +”  is not leap year”

UiPath Tutorial 7: Flowchart workflow

Compare two numbers:

1. Add flowchart workflow type.
2. Create two number variables –RandomNumber, GuessNumber- Number Variables
3. Generate random number using the random() function –new random().Next(1,10) and assign to RandomVariable
4. Take user Input from number  from 1 to 10 and assign it to GuessNumber  variable –Input dialog

Note: Add Variable as Output Result for each Input dialog box Properties

5. Condition->Compare RandomNumber,GuessNumber

GuessNumber>=RandomNumber

6. Take Decision according to the condition

If the condition is true (GuessNumber>=Randomnumber) then display a message

-“Your guessed number is equal to or greater than Random Number”.

7. If condition is False (GuessNumber<Randomnumber) then display message

-“Your guessed number is equal to or smaller than Random Number”.

8. And to display e.g. ‘Random Number is 8 and Guess Number is 6’. Add below message in message box.

“Random Number is  ”  + RandomNumber.ToString +  “and Guess Number is ” + GuessNumber.ToString

If a condition is true (GuessNumber>=Randomnumber) then display message

-“Your guessed number is equal to or greater than Random Number”.

And to display e.g  ‘Random Number is 8 and Guess Number is 6’. Add below message in the message box.

“Random Number is  ”  + RandomNumber.ToString +  “and Guess Number is ” + GuessNumber.ToString

If condition is False (GuessNumber<Randomnumber) then display message

-“Your guessed number is equal to or smaller than Random Number”.

Debug File->Run File: Enter Guess Number=8

Debug File->Run File: Enter Guess Number=3

State Machine workflow:

A state machine is a type of automation that uses a finite number of states in its execution. It can go into a state when it is triggered by an activity, and it exits that state when another activity is triggered.

Two activities – State and Final State .Both of these activities can be expanded by double-clicking them, to view more information and edit them.

State activity: conatins Entry, Exit and Transition. The Entry and Exit sections enable you to add entry and exit triggers for the selected state, while the Transition(s) section displays all the transitions linked to the selected state.

Transitions are expanded when you double-click them, just like the State activity. They contain three sections, Trigger, Condition and Action, that enable you to add a trigger for the next state, or add a condition under which an activity or sequence is to be executed.

Final State: It only contains Entry.It specifies the action to occure when the state is transioned to.           

Tutorial 08: Guess any number between 1 to 10 and find Guess Number is equal to random number.

For this need to verify the below possible state:

Guess Number >Random Number –               Retry

Guess Number <Random Number –               Retry

Guess Number =Random Number –               Final

Steps:

1. Create a blank Process –state machine workflow demo

2. On design tab-Main.xaml- double click on that and select state machine workflow-double click on it.

3. Select state activity to generate the random number. Double-click the activity. This State activity is displayed expanded in the Designer panel.

4. Create two variable RandomNumber and GuessNumebr.

5. Assign activity in entry

     RandomNumber= new Random().Next(1, 10)

6. Add message box activity in Exit criteria “Random number is generated”

7. Return to main state machine workflow and add another state activity, to enter Guess Number. Add Input dialog box add Dialog Title and Input label and store variable as output result of Input Dialog box properties.

8. Return to the main project view and create a transition that points from the Guess Number state to itself.(Display Name ->Trysmaller).

         Add condition Guessnumber > RandomNumber

        Add message box in Action “”Guess Number is greater than Random Number try for smaller number””.

• Return to Main project view and create a one more transition that points from the Guess Number state to itself.(Display Name ->Trygreater).

         Add condition Guessnumber <RandomNumber

        Add message box in Action “”Guess Number is smaller than Random Number try for greater number””.

1. Return to Main project view and add Final State (Display Name->Correct Number).

In transition add condition RandomNumber=GuessNumber.

1. Return to Main project view and connect a transition from the Guess Number activity to the Final State.

Add message box and display message “Congratulation you guessed the correct number”.

Add one more message box to display random number “The Random Number is ” + RandomNumber.ToString”.

1. The Final Project will look as following screenshot.

1. 13. Run File.

The post UIPath Tutorial appeared first on Dot Net Guide.

In C#, conditional loops are used to repeatedly execute a block of code as long as a specific condition is true. Here are some of the most commonly used conditional loops:

1.while loop: The while loop is used to execute a block of code repeatedly while a condition is true. The syntax is as follows:

while (condition)
{
    // code to be executed
}

Here, is the example of while loop,

int i = 1;
while (i <= 10)
{
    Console.WriteLine(i);
    i++;
}

This code will repeatedly print the value of i as long as it is less than or equal to 10. The output will be:

1
2
3
4
5
6
7
8
9
10

Nested while Loop

C# allows while loops inside another while loop, as shown below. However, it is not recommended to use nested while loop because it makes it hard to debug and maintain.

int i = 0, j = 1;

while (i < 2)
{
    Console.WriteLine("i = {0}", i);
    i++;

    while (j < 2)
    {
        Console.WriteLine("j = {0}", j);
        j++;
    }
}

The output of this code will be as below:

i = 0
j = 1
i = 1

2. do-while loop: The do-while loop is similar to the while loop, but the condition is checked at the end of the loop instead of the beginning. This ensures that the loop body is executed at least once. The syntax is as follows:

do
{
    // code to be executed
} while (condition);

Here is the example of do-while loop,

int i = 1;
do
{
    Console.WriteLine(i);
    i++;
} while (i <= 10);

This code will execute the block of code at least once and then repeatedly execute it as long as the condition is true. The output will be the same as the previous example:

1
2
3
4
5
6
7
8
9
10

Note that the difference between the while and do-while loops is that the while loop tests the condition at the beginning, while the do-while loop tests the condition at the end. Therefore, the block of code inside a do-while loop will always execute at least once, even if the condition is initially false.

3.for loop: The for loop is used to execute a block of code a specific number of times. It is often used when the number of iterations is known in advance. The syntax is as follows:

for (initialization; condition; iteration)
{
    // code to be executed
}
here’s an example of a for loop in C#:
for (int i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}

In this example, the loop will execute 5 times because the condition i < 5 is true. The loop consists of three parts separated by semicolons:

1. Initialization: int i = 0; initializes the loop control variable i to 0.
2. Condition: i < 5; checks whether the loop should continue executing. As long as the condition is true, the loop will execute.
3. Iteration: i++ increments the value of i by 1 after each iteration of the loop.

The output of this code will be:

0
1
2
3
4

In this example, the loop control variable i is used to print the values from 0 to 4 to the console. However, the loop control variable can be used for other purposes as well, such as accessing elements in an array or collection.

4. for each loop: The for each loop is used to iterate over the elements of an array or a collection. It automatically initializes an index variable and iterates over the elements until the end of the collection is reached. The syntax is as follows:

{
    // code to be executed
}
here’s an example of a foreach loop in C#:
int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

In this example, the loop will iterate over each element in the numbers array and print its value to the console. The syntax of the foreach loop is as follows:

foreach (type variable in collection)
{
    // code to be executed
}

Here, type specifies the data type of the elements in the collection, variable is a temporary variable that represents each element in the collection, and collection is the collection of elements to be iterated over. The loop will automatically initialize the variable with each element in the collection and execute the code inside the loop body.

The output of this code will be:

1
2
3
4
5

In this example, the loop iterates over each element in the numbers array and prints its value to the console. The loop control variable number is used to access each element in the array. However, the loop control variable can be named whatever you like, as long as it is of the same type as the elements in the collection.

The post C# Conditional Loops appeared first on Dot Net Guide.

C# Conditional Statement

In C#, conditional statements are used to execute specific blocks of code based on certain conditions.

Decision-making statements require a few conditions that can be evaluated by the program and set of statements that can be executed if the condition evaluates as true or another statement that can be executed when the condition values as false.

In this tutorial, we will be explaining how a conditional operator works with proper syntax explanation and some interesting examples. We will also be looking into nested and other different conditional statements.

Lets have look on flow chart of Conditional statement ,

1.if statement: The if statement is used to execute a block of code only if a certain condition is true. Here is the syntax:

if (condition)
{
    // code to be executed if the condition is true
}

here is the example of If statement,

using System;

namespace Conditional
{
	class IfStatement
	{
		public static void Main(string[] args)
		{
			int number = 2;
			if (number < 5)
			{
				Console.WriteLine("{0} is less than 5", number);
			}

			Console.WriteLine("This statement is always executed.");
		}
	}
}

When we run the program, the output will be:

2 is less than 5
This statement is always executed.

The value of number is initialized to 2. So the expression number < 5 is evaluated to true. Hence, the code inside the if block are executed. The code after the if statement will always be executed irrespective to the expression.

Now, change the value of number to something greater than 5, say 10. When we run the program the output will be:

This statement is always executed.

The expression number < 5 will return false, hence the code inside if block won’t be executed.

2. if-else statement: The if-else statement is used to execute one block of code if a condition is true, and another block of code if the condition is false. Here is the syntax:

if (condition)
{
    // code to be executed if the condition is true
}
else
{
    // code to be executed if the condition is false
}

Here is the example of If else statement,

using System;

namespace Conditional
{
	class IfElseStatement
	{
		public static void Main(string[] args)
		{
			int number = 12;

			if (number < 5)
			{
				Console.WriteLine("{0} is less than 5", number);
			}
			else
			{
				Console.WriteLine("{0} is greater than or equal to 5", number);
			}

			Console.WriteLine("This statement is always executed.");
		}
	}
}

When we run the program, the output will be:

12 is greater than or equal to 5
This statement is always executed.

Here, the value of number is initialized to 12. So the expression number < 5 is evaluated to false. Hence, the code inside the else block are executed. The code after the if..else statement will always be executed irrespective to the expression.

Now, change the value of number to something less than 5, say 2. When we run the program the output will be:

2 is less than 5
This statement is always executed.

The expression number < 5 will return true, hence the code inside if block will be executed.

3. switch statement: The switch statement is used to execute different blocks of code depending on the value of a variable. Here is the syntax:

switch (variable)
{
    case value1:
        // code to be executed if variable equals value1
        break;
    case value2:
        // code to be executed if variable equals value2
        break;
    // add more cases as needed
    default:
        // code to be executed if none of the cases are true
        break;
}

The switch statement evaluates the expression (or variable) and compare its value with the values (or expression) of each case (value1, value2, …). When it finds the matching value, the statements inside that case are executed.

But, if none of the above cases matches the expression, the statements inside default block is executed. The default statement at the end of switch is similar to the else block in if else statement.

However a problem with the switch statement is, when the matching value is found, it executes all statements after it until the end of switch block.

To avoid this, we use break statement at the end of each case. The break statement stops the program from executing non-matching statements by terminating the execution of switch statement.

using System;
 
namespace Conditional
{
    class SwitchCase
    {
        public static void Main(string[] args)
        {
            char ch;
            Console.WriteLine("Enter an alphabet");
            ch = Convert.ToChar(Console.ReadLine());
 
            switch(Char.ToLower(ch))
            {
                case 'a':
                    Console.WriteLine("Vowel");
                    break;
                case 'e':
                    Console.WriteLine("Vowel");
                    break;
                case 'i':
                    Console.WriteLine("Vowel");
                    break;
                case 'o':
                    Console.WriteLine("Vowel");
                    break;
                case 'u':
                    Console.WriteLine("Vowel");
                    break;
                default:
                    Console.WriteLine("Not a vowel");
                    break;
            }
        }
    }
}

When we run the program, the output will be:

Enter an alphabet
X
Not a vowel

In this example, the user is prompted to enter an alphabet. The alphabet is converted to lowercase by using ToLower() method if it is in uppercase.

Then, the switch statement checks whether the alphabet entered by user is any of a, e, i, o or u.

If one of the case matches, Vowel is printed otherwise the control goes to default block and Not a vowel is printed as output.

4.Nested If Statement:

In C#, nested if statements are used to execute a set of instructions if the condition in the outer if statement is true, and then execute another set of instructions if the condition in the inner if statement is true as well.

Here’s an example of nested if statements in C#:

if (condition1)
{
    // code to execute if condition1 is true

    if (condition2)
    {
        // code to execute if condition1 and condition2 are true
    }
}
else
{
    // code to execute if condition1 is false
}

Here is the example of Nested if statement,

int x = 10;
int y = 20;

if (x == 10)
{
   Console.WriteLine("x is equal to 10");
   if (y == 20)
   {
      Console.WriteLine("y is equal to 20");
   }
   else
   {
      Console.WriteLine("y is not equal to 20");
   }
}
else
{
   Console.WriteLine("x is not equal to 10");
}

In this example, there are two variables ‘x‘ and ‘y‘. The outer if statement checks whether ‘x‘ is equal to 10. If it is, then the inner if statement checks whether ‘y‘ is equal to 20. If both conditions are true, then the program outputs the message “x is equal to 10” and “y is equal to 20”. If ‘y‘ is not equal to 20, then the program outputs the message “y is not equal to 20”. If ‘x‘ is not equal to 10, then the program outputs the message “x is not equal to 10”.

The post C# Conditional Statements appeared first on Dot Net Guide.

In this tutorial, you will learn about the concept of C# classes and objects with the help of examples.

In Previous article we learned about C# Program structure and data types and now in this article we will learn about C# classes and objects using various examples. Similar to most of the object-oriented programming languages C# also has inbuilt support for C# classes and objects.

C# Classes and Objects

In C#, a class is a blueprint or a template for creating objects. An object is an instance of a class. C# is associated with classes and objects, along with its attributes and methods.

To work with objects, we need to perform the following activities:

• create a class
• create objects from the class

C# Class:

Before we learn about objects, we need to understand the working of classes. Class is the blueprint for the object.

Here’s an example of a simple class in C#:

public class Car
{
    public string Make;
    public string Model;
    public int Year;

    public void Drive()
    {
        Console.WriteLine("Driving the {0} {1}...", Make, Model);
    }
}

In this example, we have defined a class called “Car“. It has three public properties: “Make“, “Model“, and “Year“, which can be accessed from outside the class. It also has a public method called “Drive” that writes a message to the console.

C# Objects:

An object is an instance of a class. Suppose, to create an object of this class, we can use the “new” keyword:

Classname obj= new Classname();

This creates a new instance of the “Car” class and assigns it to the variable “myCar“. We can then set the properties of the object like this:

Car myCar= new Car();

myCar.Make = "Toyota";
myCar.Model = "Corolla";
myCar.Year = 2018;

And we can call the “Drive” method like this:

myCar.Drive();

This will output the message “Driving the Toyota Corolla…” to the console.

Classes can have constructors, which are special methods that are called when an object is created. Constructors can be used to initialize the object’s properties or perform other setup tasks. Here’s an example of a class with a constructor:

public class Person
{
    public string Name;
    public int Age;

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    public void SayHello()
    {
        Console.WriteLine("Hello, my name is {0} and I'm {1} years old.", Name, Age);
    }
}

In this example, we have a class called “Person” that has two properties: “Name” and “Age”. We also have a constructor that takes two parameters: “name” and “age”. This constructor sets the “Name” and “Age” properties of the object.

We can create an instance of the “Person” class like this:

Person john = new Person("John", 30);

This creates a new instance of the “Person” class with the “Name” property set to “John” and the “Age” property set to 30. We can then call the “SayHello” method like this:

john.SayHello();

This will output the message “Hello, my name is John and I’m 30 years old.” to the console.

Constructor :

In C#, a constructor is a special method that is used to initialize objects when they are created. It has the same name as the class and does not have a return type, not even void.

Here is an example of a constructor in C#:

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    // Constructor with parameters
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }

    // Default constructor
    public Person()
    {
        Name = "John Doe";
        Age = 18;
    }
}

// Creating an object of the Person class using the constructor with parameters
Person person1 = new Person("Alice", 25);

// Creating an object of the Person class using the default constructor
Person person2 = new Person();

In this example, we have defined a class ‘Person‘ with two properties, ‘Name‘ and ‘Age‘. We have also defined two constructors for this class – one that takes two parameters (‘name‘ and 'age') and one that doesn’t take any parameters.

When we create an object of the ‘Person' class using the constructor with parameters, we pass in values for the ‘name‘ and ‘age‘ parameters. These values are then used to initialize the ‘Name‘ and ‘Age‘ properties of the object.

When we create an object of the Person class using the default constructor, the ‘Name‘ property is set to “John Doe” and the ‘Age‘ property is set to 18 by default.

Methods:

Methods are functions that are defined within a class. They are used to perform specific tasks or operations. C# is a popular programming language used to build a variety of applications ranging from desktop applications to web services.

Here’s an example of a method in C#:

// Define a method to calculate the sum of two integers
public int CalculateSum(int a, int b)
{
    return a + b;
}

In the example above, we defined a method called ‘CalculateSum‘ that takes two integers as arguments (‘a' and ‘b') and returns their sum. Here are the key parts of this method:

• ‘public‘: This keyword indicates that the method is accessible from outside the class in which it’s defined.
• ‘int‘: This is the return type of the method. In this case, the method returns an integer value.
• ‘CalculateSum‘: This is the name of the method.
• ‘(int a, int b)‘: These are the parameters that the method accepts. In this case, the method accepts two integers called ‘a‘ and ‘b‘.
• ‘return a + b';: This is the body of the method. It adds the values of a and b and returns the result.

To call this method, you would use code like this:

int result = CalculateSum(2, 3);
Console.WriteLine(result); // Output: 5

In this example, we’re calling the ‘CalculateSum‘ method and passing in the values 2 and 3 as arguments. The method calculates the sum of these values and returns the result, which we store in the result variable. We then output the value of result to the console, which displays the result 5.

Inheritance:

Inheritance is a powerful feature in C# that allows you to create new classes based on existing classes. Inheritance enables you to reuse the code in a base class and extend it by adding new functionality or modifying existing behavior.

Here’s an example of how to use inheritance in C#:

// Define a base class called Animal
public class Animal
{
    // Declare a protected string field
    protected string name;

    // Define a constructor to set the name field
    public Animal(string name)
    {
        this.name = name;
    }

    // Define a virtual method called MakeSound
    public virtual void MakeSound()
    {
        Console.WriteLine("The animal makes a sound.");
    }
}

// Define a derived class called Cat that inherits from Animal
public class Cat : Animal
{
    // Define a constructor that calls the base class constructor
    public Cat(string name) : base(name)
    {
    }

    // Override the MakeSound method to make a cat-specific sound
    public override void MakeSound()
    {
        Console.WriteLine("Meow!");
    }
}

In the example above, we defined a base class called ‘Animal‘ with a protected field ‘name‘, a constructor to set the ‘name‘ field, and a virtual method called ‘MakeSound‘. We also defined a derived class called Cat that inherits from ‘Animal' and overrides the ‘MakeSound‘ method.

Here are the key parts of this example:

• ‘public class Animal‘: This is the base class.
• ‘protected string name‘: This is a protected field that stores the name of the animal.
• ‘public Animal(string name)‘: This is a constructor that sets the ‘name' field.
• ‘public virtual void MakeSound()‘: This is a virtual method that outputs a generic sound.
• ‘public class Cat: Animal‘: This is the derived class that inherits from ‘Animal'.
• ‘public Cat(string name) : base(name)‘: This is a constructor that calls the base class constructor to set the ‘name‘ field.
• ‘public override void MakeSound()‘: This is a method that overrides the ‘MakeSound‘ method of the base class to output a cat-specific sound.

To use this inheritance hierarchy, you would create an instance of the ‘Cat‘ class and call its ‘MakeSound' method:

Cat cat = new Cat("Fluffy");
cat.MakeSound(); // Output: Meow!

In this example, we create a new ‘Cat' object called ‘cat' and pass in the name “Fluffy” to the constructor. We then call the ‘MakeSound' method on the cat object, which outputs the cat-specific sound “Meow!”. Because ‘Cat‘ inherits from ‘Animal', it also has access to the ‘name‘ field and the ‘MakeSound‘ method of the ‘Animal' class.

Polymorphism:

Polymorphism is a fundamental concept in object-oriented programming that allows you to write code that can work with objects of multiple types. In C#, polymorphism is achieved through method overriding and method overloading.

Method Overriding: Method overriding occurs when a derived class provides a different implementation of a method that is already defined in its base class. Here’s an example of how to use method overriding to implement polymorphism in C#:

// Define a base class called Shape
public class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape.");
    }
}

// Define a derived class called Circle that overrides the Draw method
public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

// Define a derived class called Rectangle that overrides the Draw method
public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

In the example above, we defined a base class called ‘Shape‘ with a virtual ‘Draw‘ method, and two derived classes called ‘Circle‘ and ‘Rectangle‘ that override the ‘Draw' method.

Here are the key parts of this example:

• ‘public class Shape‘: This is the base class.
• ‘public virtual void Draw()‘: This is a virtual method that outputs a generic message.
• ‘public class Circle : Shape‘: This is the derived class that overrides the Draw method to output a circle-specific message.
• ‘public override void Draw()‘: This is a method that overrides the Draw method of the base class to output a circle-specific message.
• ‘public class Rectangle' : Shape: This is the derived class that overrides the Draw method to output a rectangle-specific message.
• ‘public override void Draw()‘: This is a method that overrides the Draw method of the base class to output a rectangle-specific message.

To use polymorphism with these classes, you would create instances of the Circle and ‘Rectangle' classes and call their ‘Draw' methods:

Shape circle = new Circle();
Shape rectangle = new Rectangle();

circle.Draw(); // Output: Drawing a circle.
rectangle.Draw(); // Output: Drawing a rectangle.

In this example, we create two objects, ‘circle‘and ‘rectangle‘, of the base class type ‘Shape'. We then instantiate ‘circle' as an instance of the derived ‘Circle‘ class, and ‘rectangle' as an instance of the derived ‘Rectangle' class. We call the ‘Draw' method on both objects, which outputs the circle-specific and rectangle-specific messages, respectively.

Method Overloading: Method overloading occurs when multiple methods have the same name, but different parameter types or numbers. Here’s an example of how to use method overloading to implement polymorphism in C#:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }
}

In the example above, we defined a class called ‘Calculator‘ with two methods called ‘Add', one that takes two integers and another that takes two doubles. These two methods have the same name but different parameter types.

To use polymorphism with these methods, you would call them with different parameter types:

Calculator calculator = new Calculator();

int result1 = calculator.Add(2, 3); // Returns 5
double result2 = calculator.Add(2.5, 3.5); // Returns 6.0

In this example, we create a new ‘Calculator‘ object called ‘calculator‘. We then call the ‘Add‘.

Encapsulation :

Encapsulation is one of the fundamental concepts of object-oriented programming (OOP) in C#. It refers to the practice of bundling related data (fields) and behavior (methods) into a single unit, usually a class, and controlling access to that unit through a well-defined interface.

In C#, encapsulation is achieved by using access modifiers such as public, private, protected, internal, and protected internal to control the visibility and accessibility of class members, such as fields, methods, and properties.

By making certain members private, you can ensure that they are not accessed or modified by code outside the class, thus preventing unauthorized access or modification of internal state. Instead, access to those members is provided through public or protected methods, properties, or events.

Encapsulation provides several benefits, including:

• Improved code maintainability and modularity: Encapsulation allows you to hide the implementation details of a class from other parts of the program, making it easier to modify or update the class without affecting the rest of the program.
• Improved code readability and understanding: Encapsulation provides a clear and concise interface for interacting with a class, making it easier to read and understand the purpose and behavior of the class.
• Improved code reusability: Encapsulation allows you to reuse code by creating objects from classes that have well-defined interfaces and encapsulated state.

Here is an example of encapsulation in C#:

public class Employee
{
    private string name;
    private int age;

    public Employee(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

    public string GetName()
    {
        return name;
    }

    public int GetAge()
    {
        return age;
    }

    public void SetName(string name)
    {
        this.name = name;
    }

    public void SetAge(int age)
    {
        this.age = age;
    }
}

In this example, we have defined a class ‘Employee‘with private fields ‘name‘and ‘age'. We have provided public getter and setter methods for these fields using the 'GetName', ‘GetAge', ‘SetName', and ‘SetAge' methods. By making the fields private and providing public access to them through the getter and setter methods, we have encapsulated the internal state of the ‘Employee ‘class and provided a well-defined interface for interacting with it.

A class serves as a blueprint for defining user-defined data types in programming. It allows for grouping of similar objects and encapsulating their data and functionality. Objects, on the other hand, are runtime entities created from a class to access its members.

To create a new class, the “class” keyword is used, followed by the name of the class. Optional modifiers or attributes can be specified for the class. The members of the class, including data and functionality, are declared within curly braces “{}”. This declaration establishes the structure and behaviour of objects that will be created based on the class. So, a class declaration in programming typically starts with the “class” keyword, followed by the class name and curly braces to enclose its members. This allows for defining custom data types and their associated behaviours. Then, objects can be instantiated from the class to represent specific instances of the defined data type, with access to the members (data and functionality) defined in the class. In this way, C# classes and objects provide a way to model real-world entities and their behaviours in software development.

The post C# Classes and Objects appeared first on Dot Net Guide.

We discussed about C# Program Structure and Basic Program in our previous tutorial.

For easy understanding, in this C# tutorial will learn all about C# Data Types And Variables with simple examples.

C# is a strongly typed language, which means that every variable and expression has a specific data type that determines the range of values it can hold and the operations that can be performed on it.

Some common data types in C# include:

1.int – In C#, the integer data type is represented by the keyword int. It is a 32-bit signed integer and can hold values ranging from -2,147,483,648 to 2,147,483,647. Here’s an example of declaring and using an int variable in C#:

int myNumber = 42;
Console.WriteLine("My favorite number is " + myNumber);

In this example, we declare an int variable called myNumber and assign it the value of 42. We then use the Console.WriteLine() method to print a message to the console that includes the value of myNumber.

2. double – In C#, the ‘double‘ data type is used to represent double-precision floating-point numbers. It occupies 8 bytes of memory and can store a wide range of values with high precision.

Here’s an example of using double in C#:

double x = 3.14159;

double x = 3.14159; // declare a double variable and initialize it with a value

double y = x * 2; // perform a mathematical operation on the double variable

Console.WriteLine("x = {0}", x); // output the value of x to the console

Console.WriteLine("y = {0}", y); // output the value of y to the console

In this example, we declare a double variable x and initialize it with the value of 3.14159. We then perform a mathematical operation on x by multiplying it by 2 and store the result in another double variable y. Finally, we output the values of x and y to the console using the Console.WriteLine method.

The output of this program would be:

x = 3.14159
y = 6.28318

As you can see, the double data type is useful when you need to store floating-point values with a high degree of precision.

3. bool – used for boolean values (true or false)

bool isTrue = true;
bool isFalse = false;

if (isTrue)
{
    Console.WriteLine("The value of isTrue is true.");
}
else
{
    Console.WriteLine("The value of isTrue is false.");
}

if (isFalse)
{
    Console.WriteLine("The value of isFalse is true.");
}
else
{
    Console.WriteLine("The value of isFalse is false.");
}

In this example, we declare two boolean variables named isTrue and isFalse. The first variable is initialized with the value true, and the second variable is initialized with the value false.

We then use an if statement to check the value of each variable. The first if statement checks whether isTrue is true, and it prints a message indicating that the value of isTrue is true. The second if statement checks whether isFalse is true, and it prints a message indicating that the value of isFalse is false.

When we run this code, the output will be:

The value of isTrue is true.char myChar = 'A';
Console.WriteLine(myChar); // Output: A

The value of isFalse is false.

4.char –In C#, the ‘char‘ data type represents a single Unicode character. It is a 16-bit value that can hold any character in the Unicode character set.

Here’s an example of how to use the char data type in C#:

char myChar = 'A';
Console.WriteLine(myChar); // Output: A

In this example, we declare a variable myChar of type char and initialize it with the character ‘A’. We then use the Console.WriteLine() method to print the value of myChar to the console.

The char data type can also be used to represent escape sequences, which are special characters that have a specific meaning in C#. Here’s an example:

char myChar = '\n';
Console.WriteLine("Hello{0}World!", myChar); // Output: 
                                             // Hello
                                             // World!

In this example, we assign the escape sequence ‘\n’ to the myChar variable, which represents a newline character. We then use the Console.WriteLine() method to print the string “Hello” followed by the value of myChar, which causes the console to print a newline before printing the string “World!”.

5. string – In C#, a ‘string‘ is a sequence of Unicode characters. The string data type is used to represent text values, such as names, addresses, and messages. Here’s an example of how to declare and use a string variable in C#:

string message = "Hello, World!";
Console.WriteLine(message);

In this example, we declare a string variable called “message” and assign it the value “Hello, World!”. We then use the Console.WriteLine() method to output the value of the string to the console.

Strings can also be concatenated using the “+” operator:

string name = "John";
string message = "Hello, " + name + "!";
Console.WriteLine(message);

In this example, we concatenate the string “Hello, ” with the variable “name” and the string “!” to create the message “Hello, John!”. We then use the Console.WriteLine() method to output the value of the message to the console.

6. decimal –

In C#, the ‘decimal‘ data type is used to represent numbers with high precision, such as financial or monetary values, where accuracy is crucial.

Here’s an example of using decimal in C#:

decimal price = 12.99m;
decimal taxRate = 0.07m;
decimal totalPrice = price + (price * taxRate);

Console.WriteLine("Price: " + price);
Console.WriteLine("Tax Rate: " + taxRate);
Console.WriteLine("Total Price: " + totalPrice);

In the above example, we declare three variables of type decimal. We assign 12.99m to price and 0.07m to taxRate. We then calculate the totalPrice by adding the price and the tax amount (calculated as price * taxRate). Finally, we output the values of all three variables using Console.WriteLine().

Note that we append the m character to the end of the decimal values to indicate to the C# compiler that these are decimal literals, and not double or float literals.

7. float – In C#, the data type “float” is used to represent single-precision floating-point numbers. It occupies 4 bytes of memory and has a range of approximately ±1.5 x 10^-45 to ±3.4 x 10^38.

float myFloat = 3.14f;
Console.WriteLine(myFloat);

In this example, we declare a variable called “myFloat” of type “float” and assign it the value of 3.14. Note that we need to include the “f” suffix at the end of the value to indicate that it is a float literal.

We then use the “Console.WriteLine()” method to print out the value of “myFloat” to the console. The output would be:

3.14

Note that the precision of a “float” value is limited, which can result in rounding errors when performing calculations with very small or very large numbers. If you require higher precision, you may want to consider using the “double” data type instead.

Classification Of Data Types

The preceding section classifies data types based on the type of value they can hold and the amount of memory they consume. Additionally, data types can be broadly categorised into below two groups depending on how their values are stored in memory.

• Reference Type
• Value Type

1) Reference Type

Reference types do not store values directly. Instead, they store the address where the value may be located. In simpler terms, a variable of a reference type simply holds a reference to a specific memory location that could contain the necessary data.

Reference types encompass data such as strings, arrays, and classes, among others. When changes are made to the data, other variables referencing that data will automatically reflect the updated value. If a reference type variable is not assigned a value, it will contain a null value by default.

There are total three different reference type:

1. Object Type: The object type is the base class for all objects in C#. It can hold any type of value, including value types, user-defined types, and reference types. For example:

object obj = 10; //assigning an int value to an object type variable

2. Dynamic Type: The dynamic type can hold any type of value, and the type check is done at runtime instead of compile-time. This means that the variable can be assigned values of different types during runtime. For example:

dynamic dyn = 123; //assigning an int value to a dynamic type variable
dyn = "hello world"; //assigning a string value to the same variable during runtime

3. String Type: The string type is used to hold a series of character values and is represented by the System.String class. It is one of the most widely used data types in C#. For example:

string str = "hello world"; //assigning a string value to a string type variable

2) Value Type

Value type data types are variables that store a data value within their own designated memory space. Therefore, these data types hold their values directly.

Here the integer variable “i” is directly holding the value of 20.

C# DATA TYPES AND VARIABLES

In addition to these basic data types, C# also supports more complex data types such as arrays, classes, and structs.

C# Type Casting-Explicit and Implicit Conversion with example

In C#, type casting is the process of converting a value of one data type to another data type. Type casting is important when you want to perform operations on variables that are of different data types. There are two types of type casting in C#: implicit type casting and explicit type casting.

Implicit Type Casting:

Implicit type casting occurs when a smaller data type is converted to a larger data type. The compiler automatically performs this conversion without requiring any explicit conversion statements. For example:

int i = 10;
double d = i; //implicit conversion from int to double

In the above example, the value of i is implicitly converted to double because double can hold larger values than int.

Another example of implicit type casting is when you assign a literal value to a variable of a different data type, as shown below:

int i = 10;
long l = 1000;
float f = 1.23f;

Here, the values of 10, 1000, and 1.23f are implicitly converted to int, long, and float, respectively.

Explicit Type Casting:

Explicit type casting occurs when a larger data type is converted to a smaller data type. In this case, you must use a cast operator to perform the conversion. For example:

double d = 10.5;
int i = (int)d; //explicit conversion from double to int

In the above example, the value of d is explicitly converted to int using the cast operator (int).

Another example of explicit type casting is when you convert a variable of one data type to another data type using a cast operator. For example:

int i = 10;
long l = (long)i; //explicit conversion from int to long

Here, the value of i is explicitly converted to long using the cast operator (long).

It is important to note that explicit type casting can lead to loss of data if the value of the source data type is greater than the maximum value that can be held by the target data type. In such cases, the value is truncated or rounded off.

In summary, implicit type casting occurs when a smaller data type is converted to a larger data type, while explicit type casting occurs when a larger data type is converted to a smaller data type. Here are some examples of both types of type casting:

//Implicit type casting examples
int i = 10;
double d = i; //i is implicitly converted to double

float f = 1.23f;
double d = f; //f is implicitly converted to double

//Explicit type casting examples
double d = 10.5;
int i = (int)d; //d is explicitly converted to int

float f = 1.23f;
int i = (int)f; //f is explicitly converted to int

InvalidCastException

Sometimes it is possible that the compiler may not understand whether the operation performed to convert one type into another is valid or not. This causes the compiler to fail during the runtime. Once the type conversion fails, it will throw an Invalid exception.

InvalidCastException is thrown whenever an explicit or type conversion implementation is not supported by both the data types used for conversion.

In this tutorial, we learned about C# Variables and Data Types. We learned to define a variable and also discussed how to declare and initialize a variable. We saw the various data types that can be used to declare a variable.

Every data type in C# has its own set of ranges inside which the value is declared and has a default value stored. We also learned that, how we can convert one data type to another data type by using Implicit and Explicit conversion.

The post C# Data Types And Variables with examples appeared first on Dot Net Guide.

C# is a popular programming language developed by Microsoft for building Windows applications, web applications, games, and more.

C# Program Structure

A typical C# Program consists of different parts as shown below:

• Namespace
• Class
• The main method
• Methods inside the class
• Class attributes or definition
• Statements
• Comments

Here is an overview of the basic syntax and structure of a C# program:

1. C# is case-sensitive, meaning that uppercase and lowercase letters are considered different. For example, “Hello” and “hello” are two different identifiers.

2. C# programs begin with the Main method, which is the entry point of the program. The Main method has the following syntax:

static void Main(string[] args)
{
    // Code to be executed
}

3. C# uses semicolons (;) to mark the end of statements.

4. C# uses curly braces ({}) to define code blocks. A code block is a group of statements that are executed together. For example:

if (condition)
{
    // Code to be executed if the condition is true
}
else
{
    // Code to be executed if the condition is false
}

5. C# uses double slashes (//) for single-line comments, and /* and */ for multi-line comments. Comments are ignored by the compiler and are used to add notes or explanations to the code.

6. Namespace: A namespace is a grouping mechanism that organises related classes and objects. Its purpose is to prevent conflicts between different sets of objects by segregating them from each other. With namespaces, programmers can define classes in one namespace without interfering with classes in another namespace.

C# programs are typically organised into namespaces, which are containers for related classes and other type. The namespace declaration comes at the top of the file and looks like this:

 namespace MyNamespace
{
    // Classes and other types go here
}

7. Class: In C#, a class is a blueprint for creating objects. Classes can contain fields, properties, methods, and other members that define the behaviour and properties of the objects they represent. Here is an example of a class:

public class MyClass
{
    private int _myField;

    public void MyMethod()
    {
        // Code goes here
    }

    public int MyProperty { get; set; }
}

8. Statements and expressions: In C#, statements are instructions that perform some action, such as assigning a value to a variable or calling a method. Expressions, on the other hand, are combinations of values, operators, and method calls that evaluate to a single value. Here are some examples of statements and expressions:

int x = 10; // statement
int y = x + 5; // expression
Console.WriteLine("Hello, world!"); // statement

9. Control flow statements: C# includes a variety of control flow statements that allow you to control the flow of execution in your program. These include if/else statements, switch statements, loops, and more. Here are some examples:

if (x > 10)
{
    // Code goes here
}
else
{
    // Code goes here
}

switch (x)
{
    case 1:
        // Code goes here
        break;
    case 2:
        // Code goes here
        break;
    default:
        // Code goes here
        break;
}

while (x > 0)
{
    // Code goes here
    x--;
}

10. Variables: Variables are used to store data in a C# program. C# supports several types of variables, including integers, floating-point numbers, strings, and boolean. Variables are declared using the var keyword.

int myInt = 42;
float myFloat = 3.14f;
string myString = "Hello, world!";
bool myBoolean = true;

11. Operators: Operators are used to perform operations on variables in a C# program. C# supports several types of operators, including arithmetic operators (+, -, *, /), comparison operators (==, !=, <, >), and logical operators (&&, ||).

int x = 10;
int y = 20;
int z = x + y; // z is now 30
bool b = (x < y) && (y < z); // b is true

Access Modifiers:

Access modifiers define the accessibility of an object and its components. All the C# components have their own access level that can be controlled by defining the scope of accessibility for the member objects inside the class by using access modifiers.

To define the accessibility level of the object we have to declare it by using one of the keywords provided by C# language i.e. Public, Private, Protected and Internal. Access modifier is declared by using either of the keywords mentioned above before the class or a method.

• Public: Members with the public access modifier are accessible from anywhere in the application, both inside and outside of the class or struct. Example:

public class ExampleClass
{
    public int publicField = 10;
    public void PublicMethod()
    {
        // Method code here
    }
}

• Private: Members with the private access modifier are only accessible within the same class or struct.

Example:

public class ExampleClass
{
    private int privateField = 10;
    private void PrivateMethod()
    {
        // Method code here
    }
}

• Protected: Members with the protected access modifier are accessible within the same class or struct, and any derived classes.

Example:

public class BaseClass
{
    protected int protectedField = 10;
    protected void ProtectedMethod()
    {
        // Method code here
    }
}

public class DerivedClass : BaseClass
{
    public void SomeMethod()
    {
        // DerivedClass can access protectedField and ProtectedMethod from BaseClass
    }
}

• Internal: Members with the internal access modifier are accessible within the same assembly (i.e., project). Example:

internal class ExampleClass
{
    internal int internalField = 10;
    internal void InternalMethod()
    {
        // Method code here
    }
}

• Protected internal: Members with the protected internal access modifier are accessible within the same assembly and any derived classes, regardless of whether they are in the same assembly or not.

Example:

public class BaseClass
{
    protected internal int protectedInternalField = 10;
    protected internal void ProtectedInternalMethod()
    {
        // Method code here
    }
}

public class DerivedClass : BaseClass
{
    public void SomeMethod()
    {
        // DerivedClass can access protectedInternalField and ProtectedInternalMethod from BaseClass
    }
}

The post C# Program structure and Basic Syntax appeared first on Dot Net Guide.