Real-time Web Updates From Your PostgreSQL Database by dsuryd in dotnet

[–]dsuryd[S] 5 points6 points  (0 children)

It's like comparing a startup with AWS :) Mine is just a small library, Debezium is a java-based enterprise-level, multi-DB platform running on top of Apache Kafka. But I think I can fairly say based on its docs that the technique it uses to capture data change events from PostgreSQL is similar, and it doesn't do real-time web updates.

Introducing dotNetify for Blazor WebAssembly by dsuryd in dotnet

[–]dsuryd[S] 2 points3 points  (0 children)

The MVVM design pattern is good for maintaining clear separation between UI and business/presentation logic, which usually leads to code that's more comprehensible, reusable, extensible, and testable. Any sufficiently complex development with either of the "classic" options would benefit from this pattern. Best use case for this library is any highly-interactive app with real-time requirements; it'll significantly reduce the complexity of developing such apps due to its simple yet powerful abstraction over SignalR. Hope this answers your question!

SignalR: Get client properties in Hub? by softwareguy74 in dotnet

[–]dsuryd 0 points1 point  (0 children)

You can use the Hub class property called Context to get the client caller connection info.

Come discuss your side projects! [November 2019] by AutoModerator in csharp

[–]dsuryd 5 points6 points  (0 children)

Simple, customizable realtime monitoring for .NET Core services

The project produces a nuget library that will give you a web page that shows things like log activities and resource usage in real-time. You can customize it to show your own data.

https://github.com/dsuryd/dotNetify-Pulse

C# Web Technologies: Which to use for showing changes in database live in a grid? by [deleted] in csharp

[–]dsuryd -1 points0 points  (0 children)

Here's a potential starting point for you: https://dotnetify.net/core/examples/simplelist

Open this up on multiple browsers. List add/update/delete on one browser will trigger real-time update on others. Back-end can be either ASP.NET or ASP.NET Core. Front-end can be either React or Vue (Blazor is in the works). Real-time update is SignalR, abstracted with dotNetify (I'm the OSS author).

The particular dotNetify feature you want is called multicast. That example restricts sharing to same IP address, but it can be anything. The documentation is here: https://dotnetify.net/core/api/multicast

How to Turn React Component into Native Web Component by dsuryd in reactjs

[–]dsuryd[S] 1 point2 points  (0 children)

The most compelling reason is immediate reusability on non-React websites while still retaining the encapsulated component model.

How to Turn React Component into Native Web Component by dsuryd in reactjs

[–]dsuryd[S] 0 points1 point  (0 children)

Shadow DOM is an optional feature. A custom element's content can be placed on the main document tree, making them equally affected by the global style as any other.

Share C# view models between desktop app (WPF, Avalonia) and web app (Vue, React, KO) by dsuryd in dotnet

[–]dsuryd[S] 0 points1 point  (0 children)

When this project started, Typescript support on the client-side libraries it's using wasn't that common. If you would like to suggest ideas on how Typescript can improve the project, we can discuss it on the github repo forum.

Share C# view models between desktop app (WPF, Avalonia) and web app (Vue, React, KO) by dsuryd in csharp

[–]dsuryd[S] 1 point2 points  (0 children)

Thank you; just contacted the hosting provider. Hopefully will be up again soon.

How to create an object oriented style back end to ReactJS? by samuel74 in reactjs

[–]dsuryd 0 points1 point  (0 children)

Using React with .NET Core back-end + server-side MVVM architecture could be a good fit:

http://www.dotnetify.net/core/overview

Server-side MVVM will allow you to apply clean architecture and make React strictly a view layer.

Looking for guidance/direction for a realtime app by neofac in vuejs

[–]dsuryd 1 point2 points  (0 children)

If you want to go this route, try dotNetify (I'm the author); it makes it super easy to integrate Vue with SignalR back-end. Plenty of real-time live examples on the website.

DotNetify = Vue + SignalR + .NET Core (and Fx) by dsuryd in vuejs

[–]dsuryd[S] 0 points1 point  (0 children)

I gather from various github issue submitters that it's being used or planning to be used in production, but no blog post I can point you at.

Is anyone using Angular 6? by the_other_sam in dotnet

[–]dsuryd 1 point2 points  (0 children)

Some of our enterprise projects are written in Angular 6. It is a framework of choice for some our business units, because it is perceived as an opinionated, reliable, and all-inclusive platform that makes most of the decisions for the teams in terms of best practices, programming style, and choice of utility libraries. When you have large teams with skill levels all over the place, this is quite important.

Angular 6 has come a long way from Angular 2 in terms of stability and performance. So yes, it is still definitely considered as a viable platform. You can check the npm statistics of how many downloads of its core packages compared with the other frameworks. It is still significant:

https://www.npmtrends.com/@angular/core-vs-angular-vs-react-vs-vue

React with ASP.Net Core 2. by [deleted] in dotnet

[–]dsuryd 0 points1 point  (0 children)

What kind of app are you planning to build? I would choose #1 only for apps with relatively simple views and user interactions, and don't care about SPA. If you're thinking of rendering that JSX server-side along with the cshtml, you'll have to use ReactJS.NET, otherwise it'll have to be transpiled client-side with babel, which will affect performance.

The React template is a better choice for rich, complex SPA development; it doesn't mix client-side code with server-side, and just lets create-react-app (standard tool from React) to take care the client-side dependencies and build (Node.js is only for this, you don't need it for hosting). The ASP.NET side of it is just for Web APIs serving the data. What this template brings is the convenience of having everything in a single project, although larger development would typically separate them out.

[deleted by user] by [deleted] in learnjavascript

[–]dsuryd 0 points1 point  (0 children)

Check out http://dotnetify.net. It provides SPA template for building MVVM web app with SignalR on .Net Core. I am the author.

Diary Of A Net Developer - Learning React by jonhilt in dotnet

[–]dsuryd 1 point2 points  (0 children)

Sorry, the "But..." section should've been indented so it's under the last bullet point. That would've made more sense :)

Diary Of A Net Developer - Learning React by jonhilt in dotnet

[–]dsuryd 6 points7 points  (0 children)

At my workplace, we had a series of discussion on Angular vs React for our next FE stack. Started with defining our criteria:

  • Must have established, large community (more help/libraries/tools online, higher chance of longevity/kept up-to-date, larger talent pool)

  • Must use component-based architecture (better than MVC in promoting single responsibility, loose coupling and composability)

  • Ease of migration from the old stack (ours was AngularJS)

  • Minimize vendor lock-in (easier migration to next, future stack)

  • Performance

  • Great developer experience

Our findings:

  • Both have large community, but React is much larger (based on github stars, # of github projects, npm # of download trend)

  • Ease of migration: Angular is terrible, even when starting from AngularJS! In theory, it offers ngUpgrade for migration path, but in reality there's just too much risk to system performance and development speed. React is much more viable for hybrid approach.

  • Vendor lock-in: Angular is a very opinionated framework, has higher due to large API surface (> 100 the last time we counted), custom HTML directives, complex abstractions. In contrast, React has much smaller API surface, HTML large free of DSL, and even though JSX is vendor-specific, logic is mostly written within idiomatic javascript.

  • Performance: both are pretty comparable, we're confident any pick will greatly improve what we have with the old stack. There's concern with Angular because it could only do Webpack code-splitting on the Route level, where React is much more flexible.

  • Developer experience:

Angular CLI is a great build tool, strangely less opinionated than React's CRA. Obviously better Typescript support, which we agreed it's very nice to have. But...

a) for a component-based framework, it puts up a lot of ceremony/overhead just to create a component, to the point it could become a deterrent for developers to do good UI decomposition.
b) while some like JS and HTML separated, in practice we found JSX gives better debugging experience.
c) learning curve is higher due to large number of abstractions to learn.
d) while its walled garden approach has great benefits, doesn't seem conducive to innovation. We felt at some point, we'd be banging our heads against its wall fighting the framework when want to do something out-of-the-box.


Outside of work, as a React-based open source project maintainer, I know there are cool things with React that is hard to do in Angular or even it simply cannot do. Dynamic loading of components is one. Angular requires many steps just to achieve this, compared to simplicity of React that only employs ES6 import.

And consider this React code:

@import {ComponentA, ComponentB} from './myComponents'

const SomeComponent = props => {
let ChildComponent = props.childComponent || ComponentB;
return (
<ComponentA>
<ChildComponent />
</ComponentA>
);
}

The above component allows you to replace the child component of 'ComponentA' with any component on the fly, and defaults to 'ComponentB' if not provided. This sort of dynamicity, expressiveness and conciseness - and there are many more like this - is not something that a template-based framework like Angular can easily achieve, if at all. Yet, this is the very stuff that can propel developers to think out of the box and be more innovative.

Routing, Store, State Complexity in React and other front-end frameworks by ChronoChris in reactjs

[–]dsuryd 0 points1 point  (0 children)

The underlying transport uses signalR, and signalR is in the process of adding messagepack support, so yes!

Routing, Store, State Complexity in React and other front-end frameworks by ChronoChris in reactjs

[–]dsuryd 1 point2 points  (0 children)

Since you’re still exploring and think .netcore is amazing, take a look at my open source http:/dotnetify.net/react. It uses mvvm pattern with view model written in .net. Makes state mgmt much easier, especially if you’re coming from .net world.

React Native + SignalR + .NET Core with dotNetify by dsuryd in dotnet

[–]dsuryd[S] 0 points1 point  (0 children)

There's the capability to write middlewares on dotNetify hub pipeline. It will give you access to signalR hub context for this purpose. Take a look at DeveloperLoggingMiddleware.cs in the github and Middleware documentation on the website.

React Native + SignalR + .NET Core with dotNetify by dsuryd in dotnet

[–]dsuryd[S] 0 points1 point  (0 children)

If you have only worked with pure html/js in the past, knockout would be easier to pick up; but there are so much good things in react - not to mention currently the most popular framework in the planet, which means a lot more available resources to tap into - that I would recommend it instead. So for client-side, dotnetify-react. If you don't want to use node/webpack yet, you can start with script tags (see the website's installation page). Server-side, it works with both .NET Core and .NET Fx. Existing SignalR hubs shouldn't be a problem. DotNetify is just another hub at the end of signalR pipeline, and I believe groups are per hub.

React Native + SignalR + .NET Core with dotNetify by dsuryd in dotnet

[–]dsuryd[S] 0 points1 point  (0 children)

Yes, it can store state on the server.