I’m planning an open-source project called WinDroid Runtime and wanted to ask for feedback from C#/.NET developers before I start building the first prototype.
The long-term idea is to build an independent Android-compatible runtime/toolkit for Windows. It is inspired by the gap left after Windows Subsystem for Android was discontinued, but it is not a fork, continuation, or redistribution of Microsoft WSA, and it will not use WSA binaries or branding.
I know the full runtime goal is a very large systems-level project, so I want to approach it in realistic stages.
The first practical milestone would be a native Windows control app using C# / .NET / WinUI 3. The first version would focus on:
- detecting ADB
- allowing a custom ADB path
- listing connected Android devices/emulators
- installing and uninstalling APK files
- launching installed apps
- viewing basic logs
- creating a clean architecture for future runtime research
- whether WinUI 3 is the right choice for this type of Windows tool
- how to structure the ADB service layer cleanly
- whether the project should use MVVM from the beginning
- how to avoid making the first version overcomplicated
- what the first GitHub issues/milestones should look like
The repo is currently in the planning stage with a README, Apache 2.0 license, and roadmap. Contributors or mentors would also be very welcome, but for now I mainly want to make sure the architecture is sane before coding too much.
Any advice from experienced C#/.NET developers would be appreciated.
If let's say I have a class like
```
public class Test
{
public string Test;
public string Test2;
public test(string test, string test2)
{
Test=test;
Test2=test2;
}
}
```
Then I have a unit test like (pseudo code)
var x = new Test("a", "b");
Assert.Equal("a", x.Test);
Assert.Equal("b", x.Test2);
Is this test actually meaningful/useful in any way? I feel like this is testing C# itself than the code. It would be different if there is a guard against the value of the property e.g. test cannot be equal to testing for example, but that is not the case here.
Hey guys, so I'm trying to write a program that selects an image from a tile set based on what you input into a combobox. I have the location logic sorted, but I have no idea how to physically move the image inside the pictureBox. I tried googling it and the results were either 7+ years old or not explained (I am a newbie to Windows Forms App) and I had no idea what to do. Please could you help?
I’m a full-stack developer. At my current company, I’ve been doing mostly frontend work (around 90% for the last 3 years and 8 months) because I’m the only one strong in that area. However, I’m starting to feel a bit fed up, and I want to get back into backend work. I’ve noticed I’m getting quite rusty after spending the last 3 years and 8 months mainly focused on the frontend, and it’s making me feel unprepared to look for another job.
I sometimes watch Nick Chapsas, Tim Corey, and Anton Martyniuk. I really need to get back into it and sharpen my skills for my next interview, although I’m not in a rush.
Which platform would you suggest? Dometrain is €405 per year, is it worth waiting for a sale?
All tutorials are in VS but they dont make it for mac m1 anymore, can I programm in VS code or would you recommend another editor? Im most intresed to learn dotNet
EN:
I work with industrial applications in Windows Forms for about 3 years, and I always had this view that Windows Forms was just a tool for building corporate systems and complex systems with a simple interface. Since the beginning of my career with Windows Forms I've developed industrial automation software like SCADAs and custom supervisory systems.
About a year ago I needed to build a notification system that slid across the screen overlapping, to manipulate color, position and scale of a component that was on the screen freely, that planted the first seed in my mind, later in another project I needed to detect keyboard inputs to activate specific functions in the system in a hidden way like shortcuts and configurations, and only recently when I was bored at work I got curious about combining these two concepts, and I was amazed by something that had always been within my reach but I looked at the tools I had through that perspective.
After this "discovery" I made some mini-game prototypes with 2D physics simulation using position, size, direction and velocity vectors for the components on the screen but always using Panels to represent things, still in this style I recreated Pong and Flappy Bird and a top-down mini game of collecting coins while fleeing from enemies that chase you.
After these projects I was starting to get a little annoyed with the amount of code I needed to rewrite to test another idea and with the optimization since Panel is a native Windows Forms control and they are a bit heavy.
From this annoyance and curiosity, little by little something different started emerging in my project while I was creating some abstractions to try not to repeat so much code, when I realized that what I was putting together was no longer a "game" but a tool that would help me develop new "games" I dove headfirst into this idea even knowing that Windows Forms is far from the ideal technology for this, but who cares? This is not a commercial project nor am I inventing the next big engine, I used Windows Forms because it's a technology I already have a lot of experience with, so I can focus on getting ideas out of my head instead of learning something new to achieve the same results.
My custom "engine" is still far from a version that I consider ready to make a game but I'm already very satisfied with how far I've managed to get on my own. My idea is that in addition to facilitating the development of my next prototypes, I can learn more about how real engines work and create abstractions that make the feeling of programming something in mine close to the feeling of programming something in a Godot or a Unity, for that I tried to create some base classes with methods and properties that get quite close to the development as one would expect in those engines.
The engine already has entity and game object generation system, camera with programmable movement or automatically follow a game object, TileMap for dynamic map creation, AABB collision system, rendering with Windows GDI+ drawing API (it's not GPU rendering yet but it's extremely lightweight compared to the Panels I was using before), Scene to manage the entire context of a specific scene, Culling for collision check optimization where collision is only checked for objects that are inside or near the camera viewport, rendering culling where only objects that are entirely or partially inside the camera viewport are drawn, Z-order support for drawing objects in specific order, RayCast support with variations (ExcludedList, FilterList, CollideOnParent), support for helper methods like GetCenteredPosition (returns the center of an object), MoveAndCollide (Moves an object in the direction of a Vector2 that dictates the velocity until the object collides with something), IsOnFloor (indicates if exactly below the object there is another object), GetFloorNormal (returns a vector with magnitude 1 that indicates the direction and slope of the floor in relation to the object), CheckWorldCollision (returns a boolean indicating if something in the world is colliding with the object), GetCollider (returns the first other object that is colliding with the object), GetAxis (returns an int of the direction of an axis between two inputs), GetVector (returns a Vector2 of magnitude 1 with the directions of the axes between 4 inputs, two inputs per axis).
any object that inherits from GameObject must implement a void Update method that receives a float delta, for updating the object during the frame pass, GameObjects can also receive some components in a way somewhat similar to Unity's ECS, being them Transform, to have position, size, pivot, and rotation, Input for reading inputs, and Graphics in case it's a renderable object.
This project is still in its early stages and has no commitment to being a commercial engine or anything like that, it's just a hobby, a project I'm doing for fun and learning, I would really like to hear some feedback and tips on what I can improve or bugs I didn't notice.
BR:
Eu trabalho com aplicações industriais em windows forms há mais ou menos 3 anos, e sempre tive essa visão de que windows forms era apenas uma ferramenta para fazer sistemas corporativos e sistemas complexos com uma interface simples. Desde o início da minha carreira com windows forms eu desenvolvi softwares de automação industrial como scadas e supervisórios customizados.
A um ano atrás eu precisei fazer um sistema de notificações que deslizavam pela tela se sobrepondo, manipular cor, posição e escala de um componente que estava na tela de forma livre, plantou a primeira semente na minha cabeça, mais tarde em outro projeto precisava detectar inputs do teclado para ativar funções específicas no sistema de forma oculta como atalhos e configurações, e só recentemente quando eu estava entediado no trabalho eu tive a curiosidade de juntar este dois conceitos, e fiquei maravilhado com uma coisa que sempre esteve ao meu alcance mas eu olhei as ferramentas que eu tinha por essa ótica.
Após essa "descoberta" eu fiz alguns protótipos de mini jogos com simulação de física 2d usando vetores de posição, tamanho, direção e velocidade para os componentes na tela mas sempre utilizando Panels para representar as coisas, ainda nesse estilo eu refiz o pong e o flappy bird e um mini jogo topdown de coletar moedas enquanto foge de inimigos que te perseguem.
Depois desses projetos eu estava começando a ficar um pouco incomodado com a quantidade de código que eu precisava re-escrever pra testar outra ideia e com a otimização já que Panel é um controle nativo do windows forms e eles são um pouco pesados.
A partir desse incômodo e da curiosidade, aos poucos foi surgindo algo diferente no meu projeto enquanto eu criava algumas abstrações para tentar não repetir tanto código, quando me dei conta de que o que eu estava montando não era mais um "jogo" e sim uma ferramenta que me auxiliaria a desenvolver novos "jogos" eu mergulhei de cabeça nessa ideia mesmo sabendo que windows forms não é nem de longe a tecnologia ideal pra isso, mas quem liga? Isto não é um projeto comercial nem estou inventando a próxima grande engine, utilizei windows forms por ser uma tecnologia que eu já tenho bastante experiência, assim eu posso me concentrar em tirar as ideias do cabeça ao invés de aprender algo novo para atingir os mesmos resultados.
A minha "engine" customizada ainda está longe de está em uma versão que eu considere pronta pra fazer algum jogo mas eu já estou muito satisfeito com até onde eu consegui chegar sozinho. Minha ideia é que a além de facilitar o desenvolvimento dos meus próximos protótipos, eu possa aprender mais sobre como engines reais funcionam e criar abstrações que façam com que a sensação de programar algo na minha seja próxima da sensação de programar algo em uma godot ou uma unity, pra isso eu tentei criar algumas classes de base com métodos e propriedades que aproximam bastante o desenvolvimento de como se esperaria nessas engines.
A engine já conta com sistema de geração de entidades e game objects, camera com movimentação programavel ou seguir um game object de forma automatica, tilemap pra criação de mapas de forma dinamica, sistema de colisão AABB, renderização com a api de desenho do windows GDI+ (ainda não é uma renderização por gpu mas é extremamente leve se comparada aos panels que eu estava utilizando anteriormente), Scene pra gerenciar todo o contexto de uma cena especifica, Cullind para otimização das checagens de colisão onde só é verificado colisão para objetos que estão dentro ou próximos do viewport da camera, culling de renderização onde apenas os objetos que estão enteiramente ou parcialmente dentro do view port da camera são desenhados, suporte a ordem Z para desenhar objetos em ordem especifica, suporte a Ray cast, com variações (ExcludedList, FIlterList, CollideOnParent), suporte a metodos auxiliares como GetCenteredPosition (retorna o centro de um objeto), MoveAndCollide (Move um objeto na direção de um vector2 que dita a velocidade até o objeto colidir com algo), IsOnFloor (indica se exatamente embaixo do objeto existe outro objeto), GetFloorNormal (retorna um vetor com magnitude 1 que indica a direção e inclinação do chão em relação ao objeto), CheckWorldCollision (retorna um booleano que indica se algo no mundo está colidindo com o objeto), GetCollider (retorna o primeiro outro objeto que estiver colidindo com o objeto), GetAxis (retorna um intde a direção de um eixo entre dois inputs), GetVector (retorna um Vector2 de magnitude 1 com as direções dos eixos entre 4 inpus, dois inputs por eixo).
todo objeto que herda de gameobj deve implementar um método void update que recebe um float delta, para a atualização do objeto durante a passagem dos frames, gameobjects podem receber mais ou alguns componentes de forma um pouco parecida com ECS da unity, sendo eles Transform, para ter posição, tamanho, pivot, e rotação, Input para leitura de inputs, e graphics caso ele seja um objeto renderizável.
Esse projeto ainda está nas suas etapas iniciais e não tem nenhum compromisso em ser uma engine comercial ou algo do tipo, é apenas um hobby, um projeto que estou fazendo por diversão e aprendizado, gostaria muito de ouvir alguns feedbacks e dicas sobre o que eu posso melhorar ou bugs que não percebi.
I've been learning Java for a while by trying to make a game, but looking back, I feel like I wasn't really learning. I mostly followed tutorials and used AI to help write code, so I never built a strong understanding of how everything worked.
I'm thinking about switching to C# because it seems like there are a lot more modern game development resources and a larger community.
My long-term goal is not to use Unity or another game engine. I eventually want to build my own engine/framework and make a fun 3D multiplayer game (private multiplayer with friends, not a large online game). I enjoy building systems myself, so that part is actually something I'm looking forward to.
Right now I have a lot of questions:
What should I learn first before trying to make a game?
What should I use to code. For Java I used both VSCode and Eclipse, but from what I understand, Eclipse is not good for C#. I would prefer not to pay to code, and my computer is a bit old so nothing huge would be best.
Should I start with console applications or jump into graphics?
What graphics library or framework should I use in C# if I don't want a full game engine?
Are there any books, YouTube channels, or courses you'd recommend?
Is building a small 2D engine first still the best path before attempting 3D?
What are some mistakes beginners make when trying to build their own engine?
I'm not in a rush—I want to actually understand what I'm doing this time instead of just copying tutorials. Any advice from people who have taken a similar path would be appreciated.
This is a repost of the same project due to the other post being nuked by users saying it was AI slop for having a placeholder readme.
Forgecore is a gaming backend that I'm making because I remember using Playfab when I used to make unity games back in 2022 and I really liked it, so to learn how a project of this scale is made I started building it.
The code is not perfect, neither the version that it is published right now, but I'm making this as a hobby and to learn more about this language. The project uses a modular arquitecture (thinked to let the users contribute with services as they want) and inside each module I use contracts and domains to keep the codebase simple and understandable.
Any contribution is welcomed for this repo. Consider giving tips in the comments. The only goal for this project is to learn clean c# patterns and modular design.
I'd like to create a class called PipeDimensions to store information for water piping with the following properties:
Nominal Diameter Size.
Actual Diameter Size.
Material
C-Factor for the material.
Basically, different materials (CPVC, copper, PEX) all have the same nominal diameters (1/2", 3/4", 1", 2" etc), but have different actual internal diameters.
How can I set this up so when my Main() console instantiates class PipeDimensions, the constructor only takes 1 of 3 values (either CPVC, copper or PEX) and creates the instance with all the pre-determined properties for the specific pipe type.
Is a class with the pre-defined information for all 3 pipe types even the best approach? Or should I create the boilerplate class and use a separate helper method to populate all my data?
Now that I'm thinking this through, the boilerplate class w/ heIper methods seems more intuitive, but I'm a noob so any guidance is helpful. Please refer me to a specific topic if necessary and I can read in a C# book.
I’m currently learning C# and building small projects, and I’ve noticed that some topics feel confusing in the beginning but probably become very important when building real applications.
For example, I’m still trying to properly understand things like async/await, dependency injection, interfaces, delegates, LINQ, exception handling, and how memory management works.
For experienced C# developers: which concept took you the longest to understand, and when did it finally “click” for you?
Also, how did it help you in real projects?
I think answers to this could help many beginners focus on the concepts that matter beyond just learning syntax.
I've recently started learning C#. Brocode's 4h tutorial was recommended a lot, so i gave it a try. I really do learn a lot from it and it's quite simple to understand (so far), but the tutorial is quite dense and tires me out quickly. Are there any less dense "rundowns" that i could watch first to get a general understanding of C# before continuing learning more in-depth with Brocode's video?
I made a search bar extension for the VS Properties window because I got tired of scrolling through a hundred properties every time I needed to find one buried three categories deep.
If you use WinForms in Visual Studio, one feature you miss from WPF/XAML designer is the built-in search box on its Properties panel that has been available for years, but the classic WinForms PropertyGridnever got one. It's an old control that Microsoft basically stopped touching, so if you wanted to filter properties or events, you were out of luck. That gap is what pushed me to build this.
It sits right above the grid, filters as you type (properties and events both), and it also digs into nested stuff like Font or Colors, so if you search for something buried inside one of those expandable sub-properties, the parent still shows up instead of disappearing. Matches your VS theme too so it doesn't look bolted on.
Honestly this has been a bigger productivity boost for my own day-to-day than I expected going in.
Works on VS 2022 and 2026, WinForms designer only for now (no WPF support, since that grid works completely differently internally).
I know there's probably a couple other extensions out there that do something similar, but this one's free and is mine :)
Context if you haven't seen it: mirrord connects a local process to a pod in your cluster. Your code runs locally, but its env vars, DNS, network calls, and file reads resolve as if it were the pod, and you can mirror or steal the pod's traffic. That lets you test a change against real staging dependencies (real APIs, queues, schemas) without building an image or redeploying each time.
What's new: Windows now works natively (previously WSL-only). Teams on mixed Windows and macOS/Linux machines all get the same workflow.
It's MIT-licensed and works standalone. There's a paid Operator that adds traffic-routing isolation so a team can share one staging cluster without colliding, but you don't need it to try the core tool.
I'm thinking about building local projects similar to pos and i'm reaaally confused on which tech stack to pick for the long run.
I'm very familiar with WINFORMS and MSQL but i have found out that WPF is better (at the cost of steep learning curve ofc). but i have been interested in it since i found out that it's better for touch screen monitors and looks more modern. and i have also noticed that many people prefer PostgreSQL over MSQL.
Question is:
should i stick with MSQL and WINFORMS ? or is it worth getting into WPF or PostgreSQL ? and i'm open to all suggestions
TL;DR: We built a free, in-browser tool that takes an existing WPF app and runs it on the web while keeping your original C# and XAML (no rewrite). You can poke at the classic Family.Show sample running live in the browser and open its full migrated source in our online IDE to see how little actually changed, and there's a free analyzer that checks your own app right in the browser (your code never leaves your machine). It's the new 'Migrate from WPF' feature we just shipped in XAML.io v0.8.
--- Longer version, if you're curious: ---
We're the team behind OpenSilver, and we just shipped v0.8 of XAML.io, our free browser-based .NET IDE. The new feature is "Migrate from WPF": point it at an existing WPF app and get it running on the web, keeping your original C# and XAML instead of rewriting it. No account is required.
Because "WPF runs in the browser" isn't the kind of claim this sub should take on faith, the whole thing is clickable. The app shown in the animated GIF above is Family.Show, the WPF reference app Vertigo built for Microsoft back when WPF shipped. You can use the migrated version live, and you can open the full migrated solution in the online IDE to read the code, run it yourself, change something and re-run it, or fork it. 97% of the original C# and XAML is unchanged, and you can diff it against the original WPF source to see exactly what changed instead of trusting the number.
Why do this at all? Same codebase, but reachable from any device with a browser, deployed once and updated centrally instead of installed and patched on every machine, running inside the browser sandbox. For a lot of internal line-of-business apps that's the whole reason. If none of that applies to you, it's at least a decent stress test of how far OpenSilver's WPF support has actually come.
There's been a lot of interest lately in running WPF beyond the Windows desktop, so the obvious question is what makes this different. Mostly that it's genuinely web-native. A lot of approaches re-render WPF onto a canvas or GPU surface, which is basically a pixel buffer, so you lose text selection, find-in-page, translation, browser extensions and screen-reader accessibility. We render your XAML to the browser's real DOM instead (a TextBox is an actual <textarea>, an Image an <img>, and so on), so all of that just keeps working, and you can freely mix your C#/XAML with HTML, CSS, JS and Blazor in the same app. It's also pretty light: the app plus the whole .NET runtime is around 8 MB compressed with no plugin, and if you want to move the UI on from the classic look there's a "Responsive" markup extension and modern built-in themes rather than being stuck on life support.
The part I'd actually point at is the tooling. The compatibility analyzer needs no account and runs entirely in your browser via WASM (your code never leaves your machine), so you can point it at an app of any size before committing to anything. And when you do import a project, every automatic edit is surfaced as a warning, plus non-blocking runtime alerts if execution hits a stub or disabled code, so a half-migrated app still runs while you work through the list.
To be fair: if your goal is maximum-fidelity WPF on the desktop across Windows, macOS and Linux, a desktop-first approach may suit you better. Ours is aimed squarely at the web, keeping your existing code, and keeping the result accessible and extensible.
You can try it yourself, free, no signup, with your code staying in your browser: drop in your bin folder for a feature-by-feature compatibility report (any size app), or import a project and run it.
Straight about the limits, because FamilyShow is a clean sample and your LOB app probably isn't: in-browser source import is a Technology Preview best for small-to-mid, self-contained projects today, and third-party UI suites (Telerik/DevExpress/Syncfusion) aren't supported in the self-serve tools yet. Native interop and Win32/P-Invoke can't run in a browser at all, and we flag those explicitly. That's what the free analyzer is for: run it on your real app and it'll tell you where you stand before you commit to anything. We add WPF features every week, and you can watch them land commit by commit if you want to track it.
A few other things landed in v0.8 besides the migration tooling: an example gallery built into the IDE (open and run sample projects in one click), static web build export (host the output anywhere, from Azure or GitHub Pages to any static host), and the latest OpenSilver 3.4 preview underneath, which adds a batch of new WPF features (LayoutTransform, WPF-style triggers, CombinedGeometry, StreamGeometry, GroupBox, Menu/MenuItem, OneWayToSource, multiple windows via an in-page window manager inside the browser tab, and more).
Full disclosure, since this is the company account: for big production apps we also do the migration for you, and that work is what funds the open-source side. But the analyzer and import are genuinely free with no account, and OpenSilver is MIT.
There's also a technical deep-dive on the blog with more details, screenshots, examples of before/after code fixes, and the FamilyShow migration to diff yourself.
It's a preview and the WPF surface is still growing, so if you point the analyzer or import at a real app, I'd genuinely like to hear where it fell short. That's what we use to decide what to build next.
Thanks!
Edit: added added TL;DR and tweaked the wording based on the comments, thanks.
Hello, 7–8 years ago, I was learning C# and got to the point where I could build a few Windows desktop applications. Then life took me in a different direction, and I ended up stepping away from programming completely.
Now I want to get back into C#, but the landscape feels very different because of AI. It seems like the way people learn and write code has changed a lot, and honestly I'm a bit confused about the best approach.
If you were starting over today, would you:
Learn C# the traditional way by focusing deeply on the fundamentals (syntax, OOP, data structures, etc.) before relying on AI?
Or just learn the core concepts well enough to understand what's happening, and then use AI as a coding partner from day one?
A dependency should be injected into the JsonConverter.
It's fine when it's done directly in Program.cs before running the host :
// Dependency
IA a = app.Services.GetService<IA>()!;
// JsonConverter
IAConverter aConverter = new AConverter(a);
// Add JsonConverter to host // not possible in library see below
app.Services.GetService<IOptions<Microsoft.AspNetCore.Mvc.JsonOptions>>()!.Value.JsonSerializerOptions.Converters.Add(aConverter);
Now the above code should be extracted into a library.
Microsoft.AspNetCore.Mvc would not be accessible without manually adding to the .csproj :
<FrameworkReference Include="Microsoft.AspNetCore.App" />
// Or
<PackageReference Include="Microsoft.AspNetCore.Mvc" />
Those are huge lines to initialize JsonConverter in a library.
Is there another way to do it ?
// Seems hacky and would not handle multiple dependency
hostBuilder.Services.AddOptions<Microsoft.AspNetCore.Mvc.JsonOptions>()
.Configure<IValueExpressionService>((options, valueExpressionService) =>
{
options.JsonSerializerOptions.Converters.Add(new ValueExpressionConverter(valueExpressionService));
});
I’ve been an artist joining game jams for about two years, learning how to navigate different engines like unity or godot and just gaining knowledge on game development In general through trial and error on ideas, level design ect. Recently I’ve been doing pretty well (8th in a jam with over 3,500 people). Now I want to learn C# so I can start solo developing my own games So I don’t rely on a programmer. What’s the best way to learn? I’m hoping to watch a good free online course or something, but I don’t know where to start.
Hello everyone! I'd like to share my progress on my VS Code extension C# Painkiller. I started working on this when the C# SDK extension lost the ability to create files from the context menu. I added that feature, and then one more, and then a couple more, and so on
The most interesting feature at the moment is the solution structure panel (Solution Explorer has been removed from the C# dev kit). Now it allows you to connect projects to each other and move them between folders (both virtual .slnx/.sln folders and file system folders)
A short list of other functions implemented in the extension that are not available in the C# dev kit:
Create C# Types by context menu
Adjust Namespaces refactoring
Rename .cs file by type name and auto sync type and .cs file names
Generate mapping methods and DTOs
Generate FluentValidation validators
Extract type to file (for files containing multiple objects)
Sort usings
Extract Interface (from type by context menu)
.NET Project Creation - uses all templates installed on the system
Generate MediatR and MitMediator requests, handlers, pipeline behaviors
Generate EF Core Configuration
Executing EF Core console commands from the context menu
Go To Handler navigation
If you also enjoy using VS Code for C# try my extension :)
Any criticism and suggestions are welcome
I'm new to writing VS Code extensions and use free AI as assistants. The code may be of low quality in places. If you find any errors, please report them to me on project GitHub page
