7 C# Project Ideas For Beginners To Escape Tutorial Hell
Tags: beginners, programming, coding, csharp
Published: 2024-03-26 16:00:00

[7 C# Project Ideas For Beginners To Escape Tutorial Hell](https://www.devleader.ca/2024/03/18/7-c-project-ideas-for-beginners-to-escape-tutorial-hell/) appeared first on [Dev Leader](https://www.devleader.ca).

For those trying to get into software development, the question always comes up about how to spend your time most efficiently for learning. There are a seemingly unlimited number of books to choose from, online courses to navigate, YouTube videos to scroll through, and articles to scan. But many developers get stuck in what’s called “Tutorial Hell” where they jump from one tutorial to the next, unable to break the cycle. That’s why I want to share these C# project ideas for beginners that’ll help put an end to that.

In my opinion, building software is one of the best ways to learn. That doesn’t mean that the other things I mentioned aren’t helpful — I write articles, create videos, and publish courses to help people learn! But I do think that these should be supplementary to you trying to focus on building out software.

Let’s jump into these C# project ideas for beginners and get you started on building something!

{% embed https://weekly.devleader.ca/embed %} 

---

## 1 – Build a Chatbot

Building a chatbot is a great way to experiment with AI and natural language processing! You’ve probably noticed AI is getting a ton of attention unless you’ve been disconnected from civilization, so that means there’s a steady stream of new interesting things to look into.

I like working with the Azure OpenAI offering, which you can check out here: [Azure OpenAI Service](https://azure.microsoft.com/en-us/products/ai-services/openai-service). When ChatGPT was getting a lot more attention early on in its launch, I even went ahead and created some C# APIs and videos on using them!

Now, I’m no longer a fresh software developer. I haven’t been for 20 years or so. But I still thought it was a fun and exciting project to work through because it was interesting — and that will be a common theme here. You want to work on things that you find interesting so that they keep you engaged.

Even a simple chatbot can be built in a console which allows you to focus on how to follow an API spec and send/receive web requests/responses. If you reduce the problem space to just calling the API properly, you can start to add in more fancy features from there.

---

## 2 – Develop a Mobile App With Maui

There was a period early on in the C0V1D times where I [found myself with some downtime and wanted to learn](https://www.devleader.ca/2020/03/29/downtime-time-to-build/). I teamed up with a friend and we tried to build a mobile app together for fun using Xamarin (RIP). I purposefully chose different pieces of technology that I didn’t know so that I could learn about them, but I stuck with [C# as my programming language](https://www.devleader.ca/2023/03/01/c-basics-a-guide-for-new-programmers/). This allowed me to have some level of comfort as I went on to learn other things.

This may not be the same situation for you because C# is probably new to you — but that’s okay! Maybe Maui as a tech stack is new, and C# is also new… But you could make an app about something that you really love. Maybe you like cars, or sports, or video games… Make a simple app about those things so you can greatly simplify that part of the creative process. Focus your energy on the technical parts you’re trying to learn about.

Mobile app development can get difficult in some situations because of the need for specific platform knowledge. You may need to understand how to build native UI components, how to handle different device resolutions and sizes, and other situations. Maui aims to simplify a lot of this, but depending on what you’re building there could be some fun gotchas.

---

## 3 – Create a CRUD Application

Many of the applications you’ll go on to build will need to use a database at some point. So instead of building an ENTIRE application that uses a database at one point, why not just focus on building a bit of code that can interact with a database?

Creating a CRUD application is a fundamental part of many applications and services, allowing you to Create, Read, Update, and Delete data stored in a database. Using .NET technologies like Entity Framework Core, you can build an application that efficiently interacts with a database — even if it’s just a console application that allows you to do these operations! I even started documenting how I was [building a Blazor app backed by Entity Framework Core](https://www.youtube.com/watch?v=LZjQJkDYQ8I&ab_channel=DevLeader):

{% embed https://www.youtube.com/watch?v=LZjQJkDYQ8I&ab_channel=DevLeader %} 

To implement CRUD operations in C#, you can start by defining a model for your data object, such as a person or product. You could follow an entity framework tutorial to show you how to set up your connection to the database! See, not all tutorials are bad – Just have a use for them first. Once connected, you could have a console app that lets you perform the CRUD operations. You could build upon this by instead writing a REST API that calls into this same code!

… But that sounds like it might be part of the next section.

## 4 – Design a REST API

Creating a RESTful API is a great way to allow other applications to access your data or functionality. This involves designing endpoints that return or manipulate data depending on the HTTP method used. For example, a GET request could be used to retrieve data, while a POST request could be used to create new data. For our learning purposes, you really don’t need to design this for anyone else to use in practice — but you can try it out to prove it works!

And these days, it couldn’t be any easier to create a working web app with RESTful functionality in ASP.NET Core. Seriously! Check out [this video to see how to get minimal APIs working in under 5 minutes](https://www.youtube.com/watch?v=fyBhV9pWRg8) (4 minutes and 19 seconds to be exact):

{% embed https://www.youtube.com/watch?v=fyBhV9pWRg8 %} 

Here’s a bit of example code that shows how we could create a REST API for books — especially convenient if you worked on the CRUD example before this one using Entity Framework Core:

```csharp
    using Microsoft.AspNetCore.Builder;
    using Microsoft.EntityFrameworkCore;
    using Microsoft.Extensions.DependencyInjection;
    using System.Linq;
    
    var builder = WebApplication.CreateBuilder(args);
    
    // Replace with your actual database configuration
    builder.Services.AddDbContext<BookContext>(opt => 
        opt.UseInMemoryDatabase("Books"));
    // Add services to the container.
    builder.Services.AddEndpointsApiExplorer();
    builder.Services.AddSwaggerGen();
    
    var app = builder.Build();
    
    // Configure the HTTP request pipeline.
    if (app.Environment.IsDevelopment())
    {
        app.UseSwagger();
        app.UseSwaggerUI();
    }
    
    app.MapGet("/books", async (BookContext context) =>
        await context.Books.ToListAsync());
    
    app.MapGet("/books/{id}", async (BookContext context, long id) =>
    {
        var book = await context.Books.FindAsync(id);
        return book != null ? Results.Ok(book) : Results.NotFound();
    });
    
    app.MapPost("/books", async (BookContext context, Book book) =>
    {
        context.Books.Add(book);
        await context.SaveChangesAsync();
        return Results.Created($"/books/{book.Id}", book);
    });
    
    app.MapPut("/books/{id}", async (BookContext context, long id, Book updatedBook) =>
    {
        var book = await context.Books.FindAsync(id);
        if (book == null) return Results.NotFound();
    
        book.Title = updatedBook.Title;
        book.Author = updatedBook.Author;
        book.Price = updatedBook.Price;
    
        await context.SaveChangesAsync();
        return Results.NoContent();
    });
    
    app.MapDelete("/books/{id}", async (BookContext context, long id) =>
    {
        var book = await context.Books.FindAsync(id);
        if (book == null) return Results.NotFound();
    
        context.Books.Remove(book);
        await context.SaveChangesAsync();
        return Results.NoContent();
    });
    
    app.Run();
```

---

## 5 – Build a Game

This one hits home for me because this is how I started. I’ll start by saying I am absolutely awful when it comes to creating anything graphical. It’s just not a thing I’ve ever been great with — so creating games was a bit scary. But the reality is, I was never interested in creating visually appealing games, I was fascinated by building out game mechanics.

If you poke around on my blog and even some of my early YouTube videos, you can see that I even used video game creation to try and get more comfortable with content creation — it’s because it’s something I know and have experience with. And that’s only because I used it as a way to practice and learn about different ways to code, how to refactor, and how to integrate different technologies.

You can [build games in Unity using C#](https://www.devleader.ca/2021/04/26/noesisgui-the-unity-ui-framework-that-you-probably-arent-using/) and you can [build games in Godot with C#](https://docs.godotengine.org/en/stable/tutorials/scripting/c_sharp/c_sharp_basics.html) as well. But my first games were completely text-based. You really don’t need to do anything fancy to make a basic game. If you find jumping into the game engines is too difficult right away, dial it back and try making a text-based game. You could build a console trivia game with multiple choice. You could build rock paper scissors. There are probably even some card games that could be done on the console!

In my opinion, writing games is an awesome way to learn about different algorithms. You get the opportunity to start thinking about how you’d translate logical rule sets into code!

---

## 6 – Integrate with Third-Party Services

Integrating with third-party services is a powerful way to extend your .NET application’s capabilities beyond what your team can provide. This can include social media platforms or publicly accessible APIs. These APIs enable this integration, providing a defined interface for your application to interact with, and often they’re well-documented to tell you exactly how to use them.

I mentioned earlier in this article that I was using APIs for working with Azure’s OpenAI services — so that’s one such example. But you could search the internet to see if there are public data sources you could connect to maybe for weather information or something else.

One of the earlier projects was about building a REST API, and this is going in the opposite direction! Maybe after you get some practice calling other third-party APIs you can go back and check the REST API you built. How could you improve it and refactor it?

---

## 7 – Create a Full Website or App!

At this point, I’ve provided you with 6 C# project ideas for beginners that you could try to tackle. But what you may not have noticed is that each one of these could be a potential piece of a bigger application, and each of those pieces could come together in some form or another to build something more complex!

You could use your knowledge gained from building a simple CRUD app and building a REST API to get started with the basics for a back-end web server. From there, you could consider if you need to integrate with other third-party data to supplement what you have for what your web server can do.

You’ll want to decide if you go down the path of using something like Maui for building mobile applications, or perhaps [something like Blazor for building the front-end to your website](https://www.devleader.ca/2023/10/17/how-to-make-a-budgeting-app-in-c-with-blazor/). There are even Maui/Blazor hybrid options to explore!

The game concepts you may have learned if you tried out a project like that will help you think about what interesting algorithms you’ll want to provide in your service. And that first AI example with the chatbot? Now you’ll have some ideas for how you can even integrate something cool and shiny like AI into what you’re building!

---

## Wrapping Up CSharp Project Ideas For Beginners

The most important parts that you want to keep in mind when working on projects are:

* You’re learning new things
    
* You feel engaged in what you’re learning
    
* You’re having fun
    

You’ll mess up along the way. You’re going to have to rewrite and refactor code. Some code you write you’ll be embarrassed about even a week later. But every bit of that is helping you progress forward and learning how to write software. You need to put in the reps to get better, and this is how you do it! This is how you get out of tutorial hell!

If you enjoyed this article, [subscribe to Dev Leader Weekly for free](https://www.devleader.ca/newsletter/) for more content like this to your inbox, and [check out my YouTube channel](https://www.youtube.com/@devleader?sub_confirmation=1) to keep up to date. If you’re looking for additional help when it comes to getting started with C#, you can [check out my course on Dometrain](https://dometrain.com/course/getting-started-csharp?affcode=1115529_nl-teyzg):

[![Getting Started: C# - Dometrain Course](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cer9wakmsyh3zzm36gi9.jpg)](https://dometrain.com/course/getting-started-csharp?affcode=1115529_nl-teyzg)

---

## Want More Dev Leader Content?

* Follow along on this platform if you haven’t already!    
* Subscribe to my free weekly software engineering and dotnet-focused newsletter. I include exclusive articles and early access to videos:  
    [**SUBSCRIBE FOR FREE**](https://subscribe.devleader.ca/)    
* Looking for courses? Check out my offerings:  
    [**VIEW COURSES**](https://devleader.ca/courses)    
* E-Books & other resources:  
    [**VIEW RESOURCES**](https://products.devleader.ca/)    
* Watch hundreds of full-length videos on my YouTube channel:  
    [**VISIT CHANNEL**](https://youtube.com/@devleader?sub_confirmation=1)    
* Visit my website for hundreds of articles on various software engineering topics (including code snippets):  
    [**VISIT WEBSITE**](https://devleader.ca/)    
* Check out the repository with many code examples from my articles and videos on GitHub:  
    [**VIEW REPOSITORY**](https://github.com/ncosentino/DevLeader)    

{% embed https://weekly.devleader.ca/embed %}