Crea un profiloAccedi

Ricerche recenti

Nessuna ricerca recente

Opzioni di ricerca

Disponibile solo dopo aver effettuato l'accesso.
mastodon.uno è uno dei tanti server Mastodon indipendenti che puoi usare per partecipare al fediverso.
Mastodon.Uno è la principale comunità mastodon italiana. Con 77.000 iscritti è il più grande nodo Mastodon italiano: anima ambientalista a supporto della privacy e del mondo Open Source.

Amministrato da:

Statistiche del server:

6,3K
utenti attivi

mastodon.uno: InfoStatoCartella dei profiliPolitica sulla privacy

Mastodon: InfoScarica l'appScorciatoie da tastieraVisualizza il codice sorgentev4.3.7

#csharp

70 post54 partecipanti4 post oggi
Pubblico
Chris Woody Woodruff

Day 9 of learning Rust as a C# dev:
I moved a variable, and the compiler yelled at me.
It turns out that Move Semantics isn't just a feature... it's a mindset shift.

Here’s what I learned:
woodruff.dev/move-semantics-in

Chris Woody Woodruff · Move Semantics in Rust: What Just Happened to My Variable? - Chris Woody WoodruffOkay, so picture this: you're cruising along in your nice, type-safe Rust code, and suddenly... your variable vanishes. Not literally, of course. But the compiler throws a fit, and you’re left staring at an error that says something like: "value borrowed here after move". Wait, move? Welcome to move semantics, Rust’s very opinionated way of managing memory and keeping you from accidentally using things that don’t belong to you anymore. Today’s post is a follow-up to yesterday’s crash course in ownership and this one might sting a little at first if you're coming from the comfy world of .NET’s reference types. But stick with me. It’s about to make sense.
#RustLang#CSharp#DotNet
Pubblico
Norwescon

Lights, music, action - Friday night at #nwc47 is here! Time to shake off the serious and embrace the spotlight. Whether you’re a rockstar in the making or a diva at heart, DJ #CSharp hosts an electrifying karaoke extravaganza starting at 8 p.m in Maxi's. Don’t worry, liquid courage will be available. Not into singing? Slide into the glow of the Blacklight Ball with mc300baud at 9:30 p.m. in Grand 2 & 3. Dance your heart out under neon lights, where the music isn't the only thing that shines!

Pubblico
Chris Woody Woodruff

Day 8 of learning Rust as a C# dev:
Ownership is the most C++-ish thing I’ve seen in Rust, and I actually love it.
It’s strict, it’s smart, and it makes you think before you move anything.

woodruff.dev/ownership-in-rust

Chris Woody Woodruff · Ownership in Rust: The Most C++-ish Thing I’ve Loved (and I Mean That in a Good Way) - Chris Woody WoodruffLet’s get one thing out of the way: as a C# developer, I’ve never had to think too hard about memory. The garbage collector (GC) is always there, lurking in the background, sweeping up after my code, like a very polite, very invisible butler. But Rust? Rust doesn’t do garbage collection. There’s no GC.Collect(), no memory profiler needed to chase leaks from forgotten Dispose() calls. Instead, Rust gives you something bold, powerful, and… at first, kind of intimidating: Ownership. Today’s post kicks off Week 2 of my Rust adventure, and it’s all about how this one idea changes everything.
#RustLang#CSharp#DotNet
Ha risposto nella discussione
Pubblico
D. Moonfire

@maxitb I find that MSDI is good enough for 80% of my work but the more complex setups are painful.

Modular setups is the biggest reason I've defaulted to Autofac. MSDI doesn't have a baked in method for "and include DI from this project". There are extension libraries that do it but not in the core. Nor ones that give me options to extend registrations (like adding CLI commands from an assembly) or replace (having default services, then replacing them with mock or test ones).

Mostly I use that to have a single point of setup. In Nitride (my ecs ssg), I have extension methods to pull in features like Gemini, feeds, or front matter processing.

The second reason is because I do a lot of registration by interfaces. In Nitride, all of the operations are pulled in by reflection so I don't have to list each one. Autofac makes that easy, MSDI requires another library to do that.

Third is partial DI. I like Autofac's delegate handling that let's me provide some parameters for a service but then use DI for the others constructor parameters. I'm not aware of a MSDI library that does that but I know verbose techniques to do it. That let's me create a service that takes a UserId and have it passed into the constructor along with ILogger and other DI injected components.

Fourth is ascetics (much like my frustration with MS logging). MSDI's method calls are verbose on the consumption side but terse on the registration. I prefer the reverse.

Ultimately, I don't enjoy using MSDI as much as Autofac. I'm trying to convince myself to accept MSDI but I find I keep hitting its limitations or have to jump though excessive hoops compared to Autofac (such as setting up unit testing, nested scopes). And if I have to use a library to get the features I want, it seems logical to use one library that does everything cohesively across all my projects instead of making that choice per project.

That all said, I'm still trying to write my CLI library to only use MSDI and MSL (because I prefer Serilog also for the same reasons). It is painful but also a chance to see if the DX has improved since last time.

#CSharp
Pubblico
Edaqa Mortoray

I find C#'s features to always somehow be incomplete. For example, I can declare a class without a constructor, like below, and use new HandInfo{... to create with names. However, it doesn't work nullable: enable, thus I have to revert back to manually creating a constructor.

#csharp
Pubblico
D. Moonfire

Played a few hours of Palworld with Child.0.

Also worked on my C# CLI parsing library. Mostly I worked out some ideas and patterns to make sure they fit. One implementation I'm doing is based on C#'s XElement pattern:

var root = new ComponentCliCommand(
  new ValueCliOption<string>("option"),
  new ValueCliOption<int>('n', "number"),
  new SwitchCliOption("help"),
  new CliHandler(_ => Console.WriteLine("I ran a command!"));

Since the entire purpose is to make this DI-friendly and also Autofac-module friendly, all of the classes and subclasses can be extended and then added into the service provider.

public RootCommand(IEnumerable<IMyLocalVerbs> verbList, CurrentDateOption currentDateOption)
  : base(currentDateOption)
{
  this.AddRange(verbList);
}

So far, the pattern seems "reasonable"?

I can also easily convert a reflection-based version of the command and convert them into components, which would let me do a CommandLineParser-style command object. And the handler (CliHandler) doesn't have to be in the same class (though I prefer it does).

#CSharp
Pubblico
Felix Palmen :freebsd: :c64:

Today, I implemented the #async / #await pattern (as known from #csharp and meanwhile quite some other languages) ...

... in good old #C! 😎

Well, at least sort of.

* It requires some standard library support, namely #POSIX user context switching with #getcontext and friends, which was deprecated in POSIX-1.2008. But it's still available on many systems, including #FreeBSD, #NetBSD, #Linux (with #glibc). It's NOT available e.g. on #OpenBSD, or Linux with some alternative libc.

* I can't do anything about the basic language syntax, so some boilerplate comes with using it.

* It has some overhead (room for extra stacks, even extra syscalls as getcontext unfortunately also always saves/restores the signal mask)

But then ... async/await in C! 🥳

Here are the docs:
zirias.github.io/poser/api/lat

zirias.github.ioposer: PSC_AsyncTask Class Reference
#coding
Pubblico
Chris Woody Woodruff

Week 1 of learning Rust as a C# dev:

Fewer keywords. Stricter rules. More thinking.
Rust’s minimalism doesn’t just simplify, it reshapes how you code.

Here are my takeaways from the first 7 days:
woodruff.dev/reflections-on-we

Chris Woody Woodruff · Reflections on Week 1: Rust's Minimalism Hits Different - Chris Woody WoodruffSeven days into learning Rust, and I feel like I’ve been through a developer bootcamp with a compiler that doubles as a personal trainer. It doesn’t let you slack, but it does make you better. This week, I went from installing the toolchain to wrestling with immutable variables and puzzling over semicolons in return statements. As a C# developer, I expected syntax differences, but I didn’t expect the philosophical shifts. Let’s recap what stood out, what stung, and why I’m still excited to keep going.
#RustLang#CSharp#DotNet
Pubblico
Chris Woody Woodruff

I'm learning Rust from a C# developer's perspective—one day at a time for 42 days.

I have 36 days left.

If you're curious how Rust stacks up against .NET, follow along here:
woodruff.dev/from-c-to-rust-a-

Chris Woody Woodruff · From C# to Rust: A 42-Day Developer Challenge - Chris Woody WoodruffI’ve spent over a decade writing C# and building solutions on .NET. But for six weeks, we will step outside the managed world of garbage collection and runtime JIT to dive headfirst into Rust—a systems programming language that promises performance, safety, and no nulls. Over the course of 42 days, we will learn something new about Rust every single day. We will fight the borrow checker. We will make mistakes. And I will blog it all from the perspective of a C# developer trying to make sense of it.
#RustLang#CSharp#DotNet
Pubblico *
bitbonk

SpacetimeDB is an interesting new type of relational database that I haven't quite wrapped my head around yet.

It is designed for real time massive multiplayer games and uses some sort event sourcing (CRDTs?) but has many more potential use cases than just games.

It works particularly well with .NET and C#. So I have cleaned up and simplified the C# quickstart sample.

github.com/bitbonk/spacetime-q

A quickstart chat demo for SpacetimeDB. Contribute to bitbonk/spacetime-quickstart-chat development by creating an account on GitHub.
GitHubGitHub - bitbonk/spacetime-quickstart-chat: A quickstart chat demo for SpacetimeDBA quickstart chat demo for SpacetimeDB. Contribute to bitbonk/spacetime-quickstart-chat development by creating an account on GitHub.
#spacetimedb#sql#dotnet
Pubblico *
Chris Woody Woodruff

Day 6 of learning Rust as a C# dev:
No classes. No objects. Just tuples, arrays, and a compiler that keeps you honest.

Rust’s types feel simple until they don’t.

Here’s what I learned:
woodruff.dev/rust-scalar-and-c

Chris Woody Woodruff · Rust Scalar and Compound Types: Where Are My C# Classes? - Chris Woody WoodruffWhen I first started exploring Rust, one of my instincts was to reach for a class. You know the drill. Need to model some data? Write a class, slap a few properties on it, and maybe add a constructor or two. But Rust had other plans. On Day 6, I dug into Rust’s scalar and compound types and quickly realized that Rust doesn’t want you to start with classes. Instead, it hands you a small set of powerful primitives and says, “Let’s build something lean.”
#RustLang#CSharp#DotNet
EsploraFeed dal vivo
Info