dotnet

Burke Holland shares a little slice of history about #VSCode and its "overnight success" - ten years in the making.

Try out https://msft.it/6057YyyeH: https://msft.it/6058Yyyey

The Fluent UI Blazor library provides a set of Blazor components which are used to build applications that have a Fluent design (i.e. have the look and feel or modern Microsoft applications). Join Vincent and Denis to learn the fundamentals and building blocks of the library and demonstrate how to quickly incorporate it into your Blazor projects. Learn the basics of setting up the environment, use the interactive components, and change the styling of your application with Fluent UI design tokens.

⌚Chapters:

00:00 Countdown

03:06 Welcome to ASP.NET Community Standup

04:18 Community Links

12:17 Fluent UI Blazor library - a brief history

19:39 Q&A

26:42 Demo

58:45 Samples

https://github.com/microsoft/fluentui-blazor

01:12:49 Q&A

01:20:40 Wrap

Links: https://www.theurlist.com/aspnet-standup-2024-04-23

Featuring: Vincent Baaij, Denis Voituron, Jon Galloway

#blazor #dotnet

Burke and Jon continue the push to migrate off of unsupported Twitter auth. This week we try and use an Azure Functions project to do the migration so we can finally take this thing live. PLEASE!

Links: https://theurlist.com/burke-learns-blazor

#Blazor #VSCode #ASPNET

In this session we will show the integration of open-source Large Language Models (LLMs) with Semantic Kernel. This session is designed for developers and enthusiasts eager to leverage the power of AI in their .NET applications. We’ll explore how SK, can be adapted to communicate with our own hosted open-source LLM. Don’t miss out on this opportunity to expand your AI toolkit!

Links: https://www.theurlist.com/aiandnet03

Featuring: Bruno Capuano (@elbruno), Jose Luis Latorre (@joslat), Roger Barreto (@rogerbarretto)

#Beginner #AI #SemanticKernel #openSource #LLM

Fritz teaches us about how to re-use the components and features we've built with Blazor. Let's reduce the amount of code we write by centralizing markup and logic with components built with razor

Community Links: https://github.com/csharpfritz/csharp_with_csharpfritz

Featuring: Jeff Fritz (@csharpfritz)

#blazor #web #dotnet

When it comes to building robust ASP.NET Core apps, we often encounter the dilemma of choosing between monolithic and microservices architectures. While microservices offer scalability and flexibility, they also introduce complexity. Sometimes, a well-designed monolith app can be a pragmatic choice.

Featuring: Steve Smith (ardalis)

#dotnet #aspnetcore

Let's start to explore one of .NET's favorite features, LINQ (Language Integrated Query). LINQ easily enables developers to write query expressions with a declarative query syntax that allow them to perform filtering, ordering, grouping, and so much more with minimal code. Scott and Stephen are back to take you through the depths of this awesome .NET technology.

00:00:00 Exploring Programming Languages: A Discussion on Async, Link, and Modern Programming Concepts

00:02:24 Understanding Iteration and For Loops in C#

00:07:00 Understanding the Execution and State Management in Programming

00:09:32 Understanding the Select Method in Link Programming

00:11:51 Discussing the Impact of Copilot on Software Engineering Productivity

00:13:38 Understanding and Implementing Selectors in Programming

00:18:52 Exploring Programming Concepts: Implementing Select and SEAL Classes

00:23:19 Understanding and Implementing Enumeration in Computer Science

00:26:12 Exploring the Implementation of Enumerators and Selectors in Programming

00:29:20 Discussion on Implementing Non-Predicable and Nullable Referencies in Programming

00:33:47 Discussing the Implementation and Functionality of Reset in Programming

00:35:29 Understanding the Implementation and Functionality of Iteration in Programming

00:39:58 Understanding State Management and Exception Handling in Programming

00:42:47 Understanding State Machines in Programming

00:49:20 Debugging and Benchmarking in Programming

00:52:47 Exploring Performance Profilers and Zooming in for Detailed Analysis

00:56:08 Deep Dive into Code Profiling and State Management

01:03:44 Exploring Different Approaches to Implementing Omic Operations and Performance Scaling in Programming

01:08:11 Using Benchmark.net for Software Testing

01:09:30 Discussion on Implementing and Benchmarking a Compiler

01:14:45 Discussing Performance Testing and Optimization in Programming

01:16:48 Discussing Memory Allocation and Performance Profiling in Visual Studio

01:17:55 Understanding the Heisen Uncertainty Principle and Benchmark.net in Programming

01:20:03 Exploring Compiler Optimizations and Iteration Loops in Programming

01:26:50 Discussing Code Implementation and Optimization in Engineering

Docs: https://learn.microsoft.com/dotnet/csharp/linq/

Connect with .NET:

Blog: https://aka.ms/dotnet/blog

Twitter: https://aka.ms/dotnet/twitter

TikTok: https://aka.ms/dotnet/tiktok

Mastodon: https://aka.ms/dotnet/mastodon

LinkedIn: https://aka.ms/dotnet/linkedin

Facebook: https://aka.ms/dotnet/facebook

Docs: https://learn.microsoft.com/dotnet

Forums: https://aka.ms/dotnet/forums

🙋‍♀️Q&A: https://aka.ms/dotnet-qa

👨‍🎓Microsoft Learn: https://aka.ms/learndotnet

#dotnet

In this episode, Arthur Vickers and Jiri Cincura from the EF team discuss everything about mapping properties in EF Core. We’ll look at:

- The differences between properties and navigations.

- How EF decides to map a property, and whether it is mapped to a nullable column, has a max length defined, etc.

- When backing fields are used, and mapping fields directly.

- Shadow properties.

- Indexer properties.

And if we get time, we’ll look at how value converters influence all this!

Links:

https://learn.microsoft.com/ef/core/learn-more/community-standups#Apr17_2024

Featuring: Arthur Vickers and Jiri Cincura

#EFCore #DotNet #EntityFramework

Learn about cloud-native app development with .NET! Then, build your first microservice applications with .NET and Kubernetes. Come to learn something new and leave with something that we all built, together, live with experts!

Links: https://aka.ms/letslearn/dotnet/containers

Featuring: Madoka Chiyoda (@chomado), Miho Kurimoto (@Danny_miho), Nori Suzuki (@szkn27)

#AspNetCore #Containers #dotNET

Acknowledgment: This content live-streams in Japanese.

We're quite excited to see the long awaited release of Bulma 1.0 is out! We'll update the site to use it, and see if we can set up the highly prized *dark mode*! We've also got a pull request to evaluate, and maybe some discussion on what we're working through in the auth blockers slowing our production release.

Featuring: Burke Holland, Jon Galloway

#blazor #staticwebapps #bulma