ComLightInterop
csharplang
ComLightInterop | csharplang | |
---|---|---|
8 | 262 | |
44 | 10,899 | |
- | 1.1% | |
4.2 | 9.6 | |
6 months ago | 7 days ago | |
C# | C# | |
MIT License | - |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
ComLightInterop
-
Swig – Connect C/C++ programs with high-level programming languages
I have once made something remotely similar, to interop between C++ and C#: https://github.com/Const-me/ComLightInterop
I took different approach. Because I only needed to support these two languages, there’s no separate interface definition language, and no code generator for interfaces. Instead, users are expected to write both language projections manually.
Then there’s a runtime code generator on the .NET side of the interop which builds runtime callable proxy types for interfaces implemented in C++, also virtual tables for C# objects consumed by C++.
-
C# 11 Preview Updates – Raw string literals, UTF-8 and more
It’s pretty fast. Likely reason for that, MS designed both language and runtime this way since version 1.0. They needed that for their Windows Forms which consumes huge chunk of WinAPI.
I benchmarked a while ago when testing this library https://github.com/Const-me/ComLightInterop#performance On the computer I was using at that time (probably Ryzen 5 3600 CPU) the overhead was 15-20 nanoseconds per call.
-
Mach v0.1 – cross-platform Zig graphics in ~60 seconds
That thing is COM, which is a small subset of C++ ABI. Technically it’s about the same as on Windows, i.e. C ABI with extra first argument for this pointer.
Once upon a time I made this library https://github.com/const-me/comlightInterop/ The native side of the interop is idiomatic C++, here’s an example https://github.com/Const-me/ComLightInterop/blob/master/Demo... The C# side of the interop is implemented through the built-in C interop, here’s the relevant part of the library https://github.com/Const-me/ComLightInterop/blob/master/ComL... I’ve tested Linux version of that library on AMD64, ARMv7, and ARM64 CPUs, but only with gcc compiler on the native side.
-
COM+ Revisited
I like many parts of COM, but I believe that example mostly demonstrates bad parts, with IDL, registrations, and over-engineered support libraries.
There's nothing wrong with exporting factory functions from DLLs. Microsoft does it all the time, APIs like Direct3D, DirectDraw and Media Foundation don't come with type libraries are they aren't registered anywhere.
Speaking about support libraries, I once made my own: https://github.com/Const-me/ComLightInterop/tree/master/ComL... Compare examples from that article with this one: https://github.com/Const-me/ComLightInterop/blob/master/Demo... That source file is the complete DLL which implements a minimalistic COM object.
-
The Serde Rust Framework
> Does it feel "brittle" to use
Yes and no.
No because when you try to do unsupported things like calling a method on an object which doesn’t support one, you gonna get an appropriate runtime exception.
Yes because if you fail lower-level things like local parameter allocation, you gonna get an appropriate runtime exception but that one is (1) too late, I’d prefer such things to be detected when you emit the code, not when trying to use the generated code (2) Lacks the context.
Overall, when I can I’m using that higher-level System.Linq.Expressions for runtime codegen. Things are much nicer at that level. I only using the low-level thing when I need to emit new types, like there: https://github.com/Const-me/ComLightInterop/blob/master/ComL...
- Weird
-
Building a shared vision for Async Rust
> Do you have any good resources on writing dlls to consume via .net like you’re talking about?
For C APIs i.e. functions, structures and strings, the good resource is Microsoft documentation, the support is built-in, see “Consuming Unmanaged DLL Functions” section: https://docs.microsoft.com/en-us/dotnet/framework/interop/
For COM APIs i.e. sharing objects around see this library + demos: https://github.com/Const-me/ComLightInterop It’s only really needed on Linux because the desktop version of the framework has COM support already built-in, but it can be used for cross-platform things just fine, I tested that quite well i.e. not just with these simple demos.
> How do you deal with the managed memory when using the gc from .net
Most of the time, automatically.
When you calling C++ from C#, the runtime automatically pins arguments like strings or arrays. Pinning means until the C++ function returns, .NET GC won’t touch these things. This doesn’t normally make any copies: C++ will receive raw pointers/native references to the .NET objects.
Sometimes you do want to retain C# objects from C++ or vice versa i.e. keep them alive after the function/method returns. An idiomatic solution for these use cases is COM interop. IUnknown interface (a base interface for the rest of COM interfaces) allows to retain/release things across languages.
-
Experimental Nintendo Switch Emulator written in C#
C++ interop is not supported in modern .NET out of the box, but wasn't too hard to implement as a library: https://github.com/Const-me/ComLightInterop
csharplang
- Discriminated Unions: Essa feature faz falta no CSharp
-
DevDocs
Certain parts of Microsoft Learn are permissive, for example the .NET BCL documentation is Creative Commons Attribution: https://github.com/dotnet/dotnet-api-docs as is ASP.NET Core: https://github.com/dotnet/AspNetCore.Docs (a good hint if documentation is permissively licensed and on GitHub is if there's an edit button at the top.)
The C# language specification is unfortunately a bit fuzzier: https://github.com/dotnet/csharplang/discussions/4855
The updated unified C# language specification is CC, but it's still catching up to modern C#: https://github.com/dotnet/csharpstandard
-
The golden age of Kotlin and its uncertain future
No OP, but for example you still see the C# folks still struggling to add discriminated unions to the language because of complex interactions due to its too many features[1]. Virtual threads are easier to use than async/await is another example.
[1] https://github.com/dotnet/csharplang/issues/113
-
When static types make your code shorter
For example, C# had a research fork called Spec# that had compile-time support for contracts, with keywords such as requires (for arguments) and ensures (for return values), all the way back in 2004. While still being discussed, it doesn't seem to be shipping any time soon.
-
.NET 8 – .NET Blog
Hi there. I'm the language designer who created the 'Collection Expression' design/specification: https://github.com/dotnet/csharplang/issues/5354
You can see the entire history of the proposal there. To answer you specific question, we went with `..` because that's what the language already uses for the complimentary 'pattern matching deconstruction' form for collection patterns.
In other words, you can already say this today:
if (x is [var start, .. var middle, .. var end]) { ... }
-
What's new in C# 12: overview
You must specify concrete type.
There was a plan to have "natural type" so "var list = [1,2,3]" would be of type "List" but it was postponed to C# 13 (https://github.com/dotnet/csharplang/issues/5354#issuecommen...)
-
Robust Design through Value Objects in C#
While C# currently lacks direct support for this kind of functionality, there's a glimmer of hope with an active proposal under discussion that aims to bring this feature to the language. This potential addition promises a future where C# can natively offer similar robust type narrowing.
-
The combined power of F# and C#
Given few people anticipated ValueTuple and C# adding a more direct tuple syntax, I feel like it is only a matter of time before C# adds discriminated unions.
(There are multiple proposals tracking the idea. This seems the most comprehensive and "central": https://github.com/dotnet/csharplang/issues/7016)
-
Should i quit Django and move to asp.net
I always liked list abbreviations in python, but I absolutely love Linq. I believe there is a feature proposal for C# 12, which makes collection initialization better imo.
- Can constructor parameter assignment be made less verbose?
What are some alternatives?
Ryujinx - Experimental Nintendo Switch Emulator written in C#
language-ext - C# functional language extensions - a base class library for functional programming
miniserde - Data structure serialization library with several opposite design goals from Serde
jOOQ - jOOQ is the best way to write SQL in Java
mach - zig game engine & graphics toolkit
SharpLab - .NET language playground
sapio - A Bitcoin Programming Language
SQLDelight - SQLDelight - Generates typesafe Kotlin APIs from SQL
pfr - std::tuple like methods for user defined types without any macro or boilerplate code
runtimelab - This repo is for experimentation and exploring new ideas that may or may not make it into the main dotnet/runtime repo.
mach-glfw-vulkan-example - mach-glfw Vulkan example
.NET Runtime - .NET is a cross-platform runtime for cloud, mobile, desktop, and IoT apps.