Forem: Uno Platform

10 XAML Binding Pitfalls That Trip Up Even Experienced .NET Developers

mtmattei — Tue, 21 Oct 2025 02:47:16 +0000

Binding in XAML is one of the cleanest ways to keep your UI and logic in sync. You just have to know how it thinks.

Once you understand how {Binding} and {x:Bind} behave under the hood, how they resolve data, when they update, and what they quietly ignore, it stops feeling like magic and starts feeling like control.

These are the ten common binding pitfalls that, once you spot them, make XAML feel like the powerful, predictable system it was meant to be.

1. Missing DataContext

Your binding path looks correct but nothing displays. The Visual Studio XAML Binding Failures window shows "Cannot resolve symbol" errors. You forgot to set DataContext on the element or any of its ancestors.

Fix it by setting DataContext explicitly in code-behind or XAML, or use ElementName or Source to bypass DataContext entirely. In WinUI 3, {x:Bind} uses the page or control itself as the default source instead of DataContext, so you might not need DataContext at all.

For advanced scenarios where you need to bind to parent controls, check out AncestorBinding and complex UI hierarchies.

2. Binding path typos

Runtime bindings fail silently when you misspell property names because the reflection engine simply doesn't find the property. {x:Bind} catches typos at compile time, but {Binding} won't.

Switch to compiled bindings or use nameof(ViewModel.PropertyName) in code-behind scenarios. The XAML Binding Failures tool will surface typos in the error list during debugging.

If you want a quick refresher on how binding expressions are parsed, the Uno.Extensions Binding 101 guide walks through the fundamentals.

3. Wrong default binding mode

You use {x:Bind UserName} in a TextBox expecting two-way updates, but the value never propagates back to your ViewModel. WinUI's {x:Bind} defaults to OneTime, while {Binding} generally defaults to OneWay.

Add Mode=TwoWay explicitly:{x:Bind UserName, Mode=TwoWay}

Make this a code review checkpoint since it's easy to overlook.

Important Note:While {Binding} generally defaults to OneWay for most properties, certain editable properties like TextBox.Text, CheckBox.IsChecked, and Slider.Value default to TwoWay because they have BindsTwoWayByDefault metadata in their property definitions.

This means will work for two-way updates without explicitly specifying Mode=TwoWay. However, {x:Bind} always defaults to OneTime regardless of any property metadata, so you must always specify Mode=TwoWay explicitly for editable controls:

If you’d rather see real examples than theory, check out the x:Bind feature overview.

4. UpdateSourceTrigger confusion

Your TextBox binding only updates the ViewModel when the user tabs away, causing validation to feel sluggish. Both {Binding} and {x:Bind} default UpdateSourceTrigger for TextBox.Text is LostFocus.

Change to UpdateSourceTrigger=PropertyChanged for live updates:{Binding UserName, UpdateSourceTrigger=PropertyChanged} or {x:Bind UserName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}

Be aware this increases update frequency, so validate efficiently.

5. Converter overuse

You have dozens of IValueConverter classes converting booleans to visibility, numbers to strings, and dates to formatted text. Each converter invocation adds overhead and makes bindings harder to debug.

In WinUI 3, replace converters with function bindings that call methods directly:{x:Bind local:Helpers.FormatDate(User.BirthDate)}

Alternatively, add computed properties to your ViewModel that return pre-formatted values.

Note:WinUI 3 does not include a built-in BooleanToVisibilityConverter. Use CommunityToolkit.WinUI.Converters or implement your own.

The best practice in modern WinUI 3 is to use function bindings with {x:Bind} which eliminate the need for converters entirely.

6. Performance regressions in lists

Your list scrolls smoothly with 10 items but stutters with 1,000. You're using TwoWay bindings on read-only data, or you're triggering property change notifications too frequently during batch updates.

Switch read-only bindings to OneWay or OneTime. When updating multiple properties, suspend change notifications, make all changes, then raise a single notification. Consider using {x:Bind} with OneTime mode for static list data.

7. Asynchronously loaded data issues

Your bindings don't update when data loads asynchronously. The {x:Bind} initialization happens during the page's Loading event, before your async data arrives.

After loading data asynchronously, force compiled bindings to update by calling this.Bindings.Update(). For frequently changing data, use OneWay bindings instead of OneTime.

8. x:DataType missing in DataTemplates

Your DataTemplate bindings work but don't compile, losing all the performance benefits. Without x:DataType on the template, the compiler can't generate strongly typed code.

Add x:DataType="local:ItemType" to your DataTemplate definition. This enables compiled bindings for all {x:Bind} expressions within the template:

<DataTemplate x:DataType="local:Person"> <TextBlock Text="{x:Bind Name}" /> </DataTemplate>

9. Casting required for object properties

You have a property typed as object but actually containing a specific type. The binding {x:Bind MyObjectProperty.Title} results in a compile error because Title isn't found on type object.

Add a cast to your path syntax:{
x:Bind ((local:MyType)MyObjectProperty).Title}

This tells the compiler the actual type at compile time.

10. Trimming and NativeAOT breaks bindings

Your app works in debug but crashes in release when published with NativeAOT or full trimming enabled. Reflection-based bindings can't find properties because the linker removed metadata.

Migrate to compiled bindings ({x:Bind}, x:DataType}).If you absolutely need runtime bindings for dynamic scenarios, use DynamicallyAccessedMembers attributes to preserve the required metadata. Uno Platform fully supports compiled bindings across all target platforms.

Quick Reference: {Binding} vs {x:Bind}

Feature	{Binding}	{x:Bind}
Default Mode	OneWay (TwoWay for editable controls*)	OneTime
Compile-time checking	❌ No	✅ Yes
Default source	DataContext	Page/Control
Performance	Reflection (slower)	Compiled (faster)
UpdateSourceTrigger default	LostFocus	LostFocus
Function bindings	❌ No	✅ Yes
Requires x:DataType in templates	❌ No	✅ Yes

Summary

Bindings are sneaky. One minute your UI’s humming, the next, a blank screen with no clue why. It’s almost always the same villains: bad DataContext, wrong binding mode, or {Binding} doing reflection gymnastics behind your back.

{x:Bind} fixes most of that. It compiles your bindings, catches typos before runtime, and runs faster because it skips reflection. Think of it as {Binding} after a few cups of coffee and a performance review.

If you’re building with Uno Platform, use {x:Bind} by default. Keep {Binding} around only when things really have to stay dynamic. Add x:DataType, set your binding modes explicitly, and use the diagnostic tools. They may not be glamorous, but they will save your sanity.

For a deeper look at how binding ties into broader cross-platform UI patterns, see XAML Fundamentals for Web, Mobile, and Advanced Binding Techniques. or If you want to see how Uno Platform implements this system under the surface, check out the Uno UI x:Bind architecture guide.

10 Productivity Killers when using XAML (and How Hot Design Fixes Them)

mtmattei — Tue, 02 Sep 2025 18:13:15 +0000

Look, we've all been there. You make a UI change, hit build, wait for the app to compile, launch it, navigate to the right screen, and... the button's still three pixels off. Rinse and repeat. By lunch, you've aged a year and accomplished what should've taken ten minutes.

It's 2025, and you're still playing the "change-compile-pray" game.

Hot Design fixes that. With a single click, your running app becomes the designer. No context switching, no lost state, no rebuild purgatory. Just live editing where it matters

So let’s talk about ten classic XAML UI headaches and how Hot Design finally puts them out of their misery.

Uno Platform Studio
Uno Platform Studio is the premium companion to the open-source Uno Platform. It brings together a set of productivity tools; Hot Design, Hot Reload, and Design to Code—that help you move faster when building cross-platform .NET apps. No matter what OS or IDE you prefer, Studio keeps your workflow consistent and efficient.

Hot Design
Hot Design is a visual editor that works while your app is running. You can pause the app, make changes to the UI and jump right back in without a rebuild or restart. Every tweak you make stays in sync with your source code, so you get the speed of live editing without losing the reliability of your codebase.E.

1. Why do I need a full rebuild for one UI change?

The Problem: Every UI tweak requires a full rebuild. You spend more time watching progress bars than actually designing. Your coffee goes cold.

Hot Design Solution: Click once to turn your running app into a visual designer. Make your changes. Click again, and you're back in the app. No rebuild. No context switching. No existential crisis. Your changes happen in real-time on the actual running application, not some disconnected design-time surface.

2. Why does my app look different at design time vs. runtime?

The Problem: What you see in traditional designers rarely matches what you get at runtime. That perfect layout in the designer? It explodes when real data shows up. You're basically designing blind.

Hot Design Solution: You're designing on your actual running app with live data flowing through it. What you see is literally what you get because you're manipulating the real thing, not a simulation. No more surprises when you hit F5.

3. How do I test my UI with real data, not mock data?

The Problem: Mock data lies. Your beautifully crafted UI that handles five items gracefully turns into a dumpster fire with 500. You don't discover this until QA finds it. Or worse, production.

Hot Design Solution: Connect to your actual data sources and see how your UI behaves with real-world data: the good, the bad, and the "why does this user have 10,000 items in their cart?" Your data bindings update in real-time as you adjust them, so you catch issues while designing, not after shipping.

4. Do I really need to learn another UI designer??

The Problem: Most visual designers silo you into their unique environment. Different shortcuts, different workflows, different everything. You lose all your muscle memory and productivity tools.

Hot Design Solution: It works with Visual Studio, VS Code, or Rider, on any OS. Keep your key bindings, your extensions, your workflow. Hot Design adapts to you, not the other way around. Think WinForms designer, but cross-platform.

5. How do I debug responsive layouts faster?

The Problem: Testing responsive design means constantly resizing windows, switching device emulators, or maintaining a small electronics store worth of test devices. You miss edge cases until users with that one weird tablet complain.

Hot Design Solution: Switch between form factors with a single click. See instantly how your layout adapts to different screen sizes and orientations. Test on actual remote devices or emulators without redeploying. Find and fix layout issues before they find your users.

6. Do I really need to learn another flavor of XAML?

The Problem: You know what you want the UI to look like but translating that into XAML feels like writing poetry in Klingon. You type, rebuild, check, curse, repeat.

Hot Design Solution: Changes in the visual designer instantly sync to your XAML code and vice versa. See the XAML generated as you build visually, or code your XAML and watch it render live. It's bidirectional learning: you get better at XAML while being productive.

7. How do I quickly test light and dark themes?

The Problem: Supporting dark mode means testing everything twice. You inevitably miss that one label that becomes invisible in dark mode. Users notice. Twitter notices. Your manager notices.

Hot Design Solution: Toggle between light and dark mode with one click. See immediately how every element adapts. Fix theme issues on the spot, not after someone posts a screenshot of your invisible text on Reddit.

8. Where do I find the right property in XAML controls?

The Problem: XAML controls have approximately infinity properties. Finding the right one requires scrolling through endless property panels or diving into documentation. Half your day disappears into property hunting.

Hot Design Solution: Smart Properties surfaces the most important and frequently used properties right when you need them. No more spelunking through hundreds of properties to find BorderThickness. The common stuff is right there, the esoteric stuff is still available when you need it.

9. Why don’t my custom controls show up in designers?

The Problem: Your carefully crafted custom controls work great in code but turn into question mark boxes in designers. Third-party controls? Forget about it. You're designing around black boxes and hoping for the best.

Hot Design Solution: Custom and third-party controls render and behave exactly as they will at runtime because, well, they're actually running. See how that fancy chart component really looks with your data. Adjust properties and see real results, not placeholder rectangles.

10. How do I design for real app states?

The Problem: Traditional designers don't understand your app's state. You design for one scenario, but your app has fifty different states. The designer shows a perfect world that doesn't exist once real user interactions begin.

Hot Design Solution: Your MVVM or MVUX patterns work normally because you're designing against your running app. State changes reflect immediately in the designer. Design for the actual states your app will be in, not some theoretical happy path. Your view models are live, your commands work, your data flows.

The Bottom Line

Hot Designisn't just another visual designer for developers. It's a fundamental rethinking of how we build UIs. It collapses the artificial boundaries between design-time and runtime, between mockups and production.

You stay in flow. You see the real results. You ship better apps faster.

And your coffee stays hot.

Any devs actually getting a leg up using AI tools?

Sasha — Fri, 21 Feb 2025 17:49:05 +0000

There is a lengthy debate, over 400 posts on reddit as of this writing, on the topic of usefulness of AI in software development on Experienced Developers reddit.

I read and analyzed all of them, so you don’t have to, and because this topic is near and dear to my heart. The software developer productivity is what my company does, so being in tune with developers’ attitude towards AI tools is very important to me.

I’ve noticed general skepticism on twitter/bluesky about AI – and from people who’ve really tried it. Also, I’ve seen thought leadership pieces from VCs like Sequoia who go on to clam we’d be better of educating the next billion developers, then working on AI tools.

But let’s dig in the current reddit debate as it is quite good. The Original Post is copied below – verbatim. Below it you will find a more complete analysis on the good and not-so-good use cases for AI in software development.

Overall, the consensus of the thread is that AI works best as an assistant rather than an autonomous coder. Even as an assistant it must be kept a close eye on. While some people seem bullish on AI tooling, there is very strong skepticism towards AI tools but, surprisingly so, sometimes even the skeptics acknowledge AI tooling usefulness in specific scenarios

One of the Big Bosses at the company I work for sent an email out recently saying every engineer must use AI tools to develop and analyze code. The implication being, if you don't, you are operating at a suboptimal level of performance. Or whatever.
I do use ChatGPT sometimes and find it moderately useful, but I think this email is specifically emphasizing in-editor code assist tools like Gitlab Duo (which we use) provides. I have tried these tools; they take a long time to generate code, and when they do the generated code is often wrong and seems to lack contextual awareness. If it does suggest something good, it's often so dead simple that I might as well have written it myself. I actually view reliance on these tools, in their current form, as a huge risk. Not only is the code generated of consistently poor quality, I worry this is training developers to turn off their brains and not reason about the impact of code they write.
But, I do accept the possibility that I'm not using the tools right (or not using the right tools). So, I'm curious if anyone here is actually getting a huge productivity bump from these tools? And if so, which ones and how do you use them?

Most Frequent Use Cases Where Developers Found AI Helpful

Boilerplate Code Generation (Writing YAML files, API route patterns, class structures, and basic CRUD operations. Generating repetitive code like adapter methods, constructors, and ORM models.)

This one user seems to have hit them all! 😊

Auto-generating unit tests and test scaffolding
Generating READMEs, docstrings, and function explanations, summarizing code comments.
Writing SQL queries, bash scripts, and other automation scripts.
Spinning up a basic project with new frameworks and assisting with exploration in unfamiliar languages.
Code Refactoring (Simplifying or restructuring existing code and getting suggestions for improvements for readability and maintainability.

Most Frequent Cases Where AI Tools Were Not Helpful

Incorrect or Misleading Code Generation. Often, the AI-generated code appears syntactically correct but is often logically flawed. Also,devs find it faster to write code themselves rather than debugging incorrect AI-generated code. This is the most dangerous flaw, this user explaining it well

Lack of Context Awareness. AI typically struggles with large, complex codebases and fails to understand dependencies.It generates code that often works in isolation but does not integrate well with the existing system.
Inefficiency in Multi-Step Refactoring. Devs report that AI fails to maintain consistency across large projects, requiring them to manually adjust AI-generated suggestions.
Poor Code Review & PR Analysis. AI-based PR reviewers like CodeRabbit generate too many false positives, making them less useful than traditional static analysis tools.
Redundant or Overhyped Use Cases. Many devs feel that AI is being over-promoted for tasks already covered by existing tools (e.g., IDE features, linters, static analysis tools).
Over-Reliance & Skill Degradation. Not super frequent, but some developers worry that using AI for simple tasks reduces their ability to think critically and problem-solve.

Conclusion

You’d be silly not to at least try some AI tools. The summary above can give you a good idea of what some good use cases are. I’ve talked to some people who tried AI early on, and on wrong use cases, and they were turned off right from the get-go. The reality is that this space is fast evolving, and you should be in the know.

As-is today, AI tools provide some productivity gains. However, they are not replacements for experienced developers. At Uno Platform we are investing in tools which make developers productive within their current environments, such as Hot Design. Also, we are keeping a close eye and thinking of these useful scenarios to apply AI to, as we don’t believe just adding a simple LLM to it will actually add value. So, stay tuned to our blogs and Dev.to account as there is more goodness coming on this topic.

Sasha

3 more productivity tips for .NET developers

mtmattei — Mon, 07 Oct 2024 19:37:30 +0000

Welcome to the second edition of Productivity tips for .NET developers. This time around, we didn’t just stick to the Uno Platform team—we reached out to fellow developers from the .NET community to hear how they stay productive. From discovering creative ways to use new tools to sticking with those tried-and-true habits, these tips offer something for everyone.

Daren May
We asked for 3 tips and ended up with 5 — talk about being productive!

✨Top 3 Productivity Tips (+2 bonus tips):

Customize Visual Studio Window Title: Use the "Customize Visual Studio Window Title" extension to display repository and branch as well as the solution name in the VS title bar. This helps keep track of multiple instances of Visual Studio, repositories, and branches.
Embrace Command-Line and Scripting: Don't overlook the power of the command-line and scripting. Visual Studio, build systems, and Git have many powerful command-line options. Invest time in learning their full capabilities and a scripting environment like PowerShell to enhance your workflow.
Ask Questions Freely: Don't be afraid to ask questions, regardless of your position or seniority. No one knows everything, and your team, peers, and the community can all assist when an answer doesn't spring to mind. Remember, the only dumb questions are the ones that aren't asked!
Invest in Ergonomics: Pay attention to the ergonomics of your working environment. Factors like monitor height, standing desks, comfortable and supportive chairs, mouse, and keyboard can have a huge impact on your productivity and well-being over time.
**Continuous Learning: **Keep learning as nothing stands still in our field. What's considered best practice today might become legacy implementation tomorrow. Stay updated with the latest developments in the .NET ecosystem.

Follow Darren on: GitHub & Twitter

Leomaris Reyes (Microsoft MVP)

✨Top 3 Productivity Tips:

Resting is Part of Being Productive: Recognize that rest is crucial for productivity. An overworked brain doesn't function properly. When you take breaks and disconnect completely, your brain gets to rest. This can significantly improve your efficiency when you return to work.
Take Care of Your Mental Health: Pay attention to your mental health as much as your physical health. Listen to what your body tells you, whether good or bad. Don't hesitate to seek therapy when feeling exhausted, ask for a vacation when tired, or say "I can't" when overwhelmed.
Learn to Say No: Saying no is not a bad thing; it's both human and professional. Avoid overcommitting by saying yes to everything. Being selective about your commitments allows you to be 100% responsible for the tasks you do take on, leading to better quality work and less stress.

Follow Leomaris on: AskXammy& Twitter

Andres Pineda

✨Top 3 Productivity Tips:

Spend time learning your tools: Whatever tool you use to work, learn your way around it. You might not believe the amount of time you can save by using the shortcuts that are part of your developer environment.
Keep easy wins: We only sometimes have the chance to work on things that keep us motivated or when we have been working for a long time on the same task. In such situations, I often tackle low-hanging tasks that, after completion, will provide a sense of progress.
Organize your work around your most productive hours: There are times when you are more productive. Block that time in your calendar to focus solely on work

Follow Andres on: GitHub& Twitter

These productivity tips offer a range of strategies to help you work smarter, not harder. Whether it's leveraging new tools, improving ergonomics, or simply learning to say 'no,' there's something here for everyone to improve their workflow.

Have your own tips to share? We’d love to hear them! Drop your tips in the comments below and follow Uno Platform for more insights and updates from the .NET developer community.

Is the Web Browser the Most Important Platform for App Development?

mtmattei — Thu, 03 Oct 2024 14:52:41 +0000

As technologies like WebAssembly (WASM) and Progressive Web Apps (PWAs) continue to push the boundaries of in-browser functionality, the distinction between web and native applications becomes increasingly blurred. This raises a key question: has the web browser become the most important platform for app development?

The Shift in App Development

While native mobile and desktop apps continue to play a crucial role, web-based applications have come a long way. The reasons for this are clear: web browsers are everywhere, web technologies have dramatically improved, and the demand for cross-platform compatibility has surged.

But is the browser now the best target platform for apps? To answer this, I’ll explore the advantages and challenges of web browsers for app development and assess whether they’ve become the go-to platform.

Why the Web Browser Stands Out

It's widely acknowledged in the industry that the web browser has long served as a foundational platform for app development. This isn’t a new revelation; browsers have always been central in providing access to applications across devices. Their ubiquity, ease of deployment, and cross-platform nature are well-established advantages developers have leveraged for years. As these fundamentals remain strong, recent advancements in web technologies have further solidified the browser's position.

1. Web Browsers as a Ubiquitous Platform

Web browsers are found on virtually every internet-connected device, from smartphones and tablets to desktops, smart TVs, and IoT devices. This ubiquity brings several benefits:

Global Reach: A web-based application can be accessed by users around the world without needing platform-specific versions or app store approvals.
Seamless Updates: I can push updates immediately, ensuring users always access the latest version.
Cross-Device Consistency: Users experience consistent performance and data continuity across multiple devices.

With the introduction of WebAssembly, web browsers can now handle complex and computationally intensive tasks at near-native speeds:

High-Performance Web Apps: WebAssembly enables high-performance applications, such as games and video editors, to run in the browser.
Language Flexibility: Developers can build web apps using languages like C#, C++, Rust, and Go, breaking away from the traditional reliance on JavaScript.

That said, WebAssembly’s ecosystem is still fragmented. Tools like Emscripten (C/C++), wasm-bindgen (Rust), and JSGo (Go) serve different languages, but this complicates the standardization of interactions with web APIs, limiting broader WASM integration with web development.

It’s worth noting that while WebAssembly is a significant advancement, most web apps don’t use it directly or rely on it as part of third-party libraries. Web development is much broader, encompassing WebGPU, Browser APIs, ECMAScript advancements, and new CSS specifications.

WebGPU, the successor to WebGL, is particularly noteworthy because it provides direct access to the render and shader pipeline of the graphics card, bringing web performance closer to native for graphics-intensive applications.

2. Cross-Platform Development with Web Technologies

Cross-platform frameworks have solidified the role of web technologies in app development:

Unified Codebases: Frameworks like Uno Platform and .NET MAUI enable developers to write once and deploy across web and native platforms.
Web-Centric Frameworks: Web-based frameworks like Blazor or Flutter for Web allow developers to target web browsers with minimal additional effort.
Cost Efficiency: Building a single app for multiple platforms reduces development and maintenance costs, making the browser appealing.

3. Progressive Web Apps (PWAs): Bridging the Gap

PWAs have revolutionized web apps by offering features traditionally found only in native apps:

Native-like Experience: PWAs allow offline access, push notifications, and device hardware integration.
Instant Accessibility: PWAs can be accessed directly via a browser, bypassing app store downloads.
Automatic Updates: PWAs ensure users have the latest version by updating themselves automatically.

However, WebAssembly still faces challenges with browser integration, particularly with accessing the DOM (Document Object Model). While frameworks like Dioxus and Sycamore (Rust) have made progress, the lack of native DOM access remains a limiting factor for WASM's potential in web apps.

It's worth noting that there's a growing "grey area" with hybrid solutions like Uno Platform, Electron, and Blazor Hybrid, which further blur the lines between web and native applications. These frameworks allow developers to leverage web technologies while still accessing native features, including local storage (HDD/SSD) access, balancing web flexibility and native capability.

4. Economic and Market Considerations

From a business perspective, web apps offer significant advantages:

Rapid Iteration: Web apps can be updated instantly without the delays imposed by app store review processes.
Lower Distribution Costs: Web apps bypass app store fees, which can result in cost savings.
Market Flexibility: Web apps allow businesses to test and iterate ideas quickly without committing to native development.

Web apps also offer significant advantages in terms of maintenance. Developers don't need to support multiple versions of their product across different platforms. Instead, they can focus on maintaining a single, up-to-date version that's immediately accessible to all users with a reasonably current browser. This streamlined approach to maintenance can lead to significant time and cost savings over the lifecycle of an application.

Challenges of Web Browsers for App Development

Despite its many advantages, web browsers are not always the ideal platform, especially when compared to native apps.

1. Hardware Utilization and Performance

Native applications fully leverage a device’s hardware, offering advantages in:

High-Performance Apps: Applications requiring heavy computing power, such as 3D rendering or real-time video processing, are better suited to native platforms.
Device-Specific Features: Native apps can better integrate with hardware features like cameras, GPS, and local storage.

WebAssembly, though performant, still encounters specific bottlenecks. For example, string encoding mismatches (UTF-8 in Rust vs. UTF-16 in JavaScript) can cause performance hiccups. Additionally, WASM’s ability to fully harness hardware capabilities, particularly in browsers, is still evolving through projects like the WebAssembly System Interface (WASI).

2. Offline Capabilities

PWAs have improved offline functionality, but native apps generally provide more robust and reliable offline experiences. Apps like Google Maps, which rely on continuous background processing, still perform better as native applications.

3. User Experience & Interface Design

Native apps provide a more polished user experience because they can be fine-tuned to match each platform’s design guidelines. Web apps, on the other hand, may struggle to adapt to varying screen sizes and operating systems, leading to an inconsistent experience.

WebAssembly: Promise and Challenges

WebAssembly (WASM) holds immense potential for web development but also faces key challenges:

Fragmentation: The WASM ecosystem remains fragmented, with different tools and approaches for various languages. This fragmentation hinders broader adoption and complicates the standardization of WASM interactions with web APIs.
Standardization Efforts: Projects like WASI aim to create an ABI standard that facilitates better integration between WebAssembly and the host operating system. However, WASI’s full browser support, especially for web-specific APIs like WebGPU, is still a work in progress.
Ongoing Development: The WASM ecosystem is actively evolving, with updates to both WASM web APIs and the WASI component model.

WASI is particularly important in this space. It aims to standardize how WebAssembly interacts with system interfaces, potentially allowing developers like me to write "almost OS-native" applications in any language that can be compiled to WebAssembly. This could enable WebAssembly to run efficiently not just in browsers but directly on operating systems, expanding its potential uses.

That said, while WebAssembly and WASI hold great promise, they are still evolving technologies. Many successful web apps don’t rely on WebAssembly at all. The browser’s strength as a platform for app development comes from the entire ecosystem of web technologies, not just WebAssembly.

For more details on WebAssembly’s evolving features, visit the WebAssembly Features page. To follow the development of WASM and related feature proposals, check out WebAssembly's GitHub repository.

Hybrid Approaches: Bridging Web and Native Development

Hybrid development frameworks, like React Native and Uno Platform, address some of the trade-offs between web and native apps by allowing developers to write code that works across platforms:

React Native: Allows JavaScript to interact with native components, enabling a native-like user experience with less platform-specific code.
Uno Platform: Enables developers to build cross-platform applications with C# and XAML using a shared codebase that runs natively on various devices, allowing for a blend of performance and development efficiency.

So, is the Browser the Most Important Platform?

In short, the answer is yes—but it's complicated. The web browser has become a pivotal platform in app development thanks to its universal reach, ease of updates, and the advancements of technologies like WebAssembly and PWAs. For many developers, it's the go-to choice for building scalable, cross-platform applications quickly.

Ultimately, the web browser's strength as a development platform comes from its entire ecosystem of technologies—from JavaScript and CSS to WebGL and emerging standards like WebGPU. While WebAssembly is an exciting part of this ecosystem, it's just one piece of the puzzle. The browser's ubiquity, coupled with the rapid pace of web technology advancements and the large pool of skilled web developers, makes it an increasingly attractive platform for a wide range of applications.

So, is the browser the most important platform? It’s certainly up there, but whether it’s the most important depends on what your app needs to do—and how fast you need it to do it.

The new wave: Top 10 emerging .NET content creators

mtmattei — Tue, 03 Sep 2024 20:24:55 +0000

Whether you’re diving into .NET best practices, learning about architectural principles, or trying to wrap your head around microservices, there’s always someone willing to break things down in a way that clicks. The wealth of knowledge available in .NET community —from newsletters and blogs to vlogs and technical articles—makes it easier to keep growing and stay current.

We’ve grown accustomed to names like Scott Hanselman, Mary Jo Foley, Richard Campbell, and Tim Corey. Influencers that have become staples, not just in social media but also on conference stages, in magazine articles, and beyond.

But who are some of the newer .NET content creators who might one day reach the heights of these established figures? While this list is by no means exhaustive, it’s a great starting point to discover fresh perspectives and perhaps find a few creators you haven’t come across yet.

The List

1. Steven Giesel

About the author: Steven Giesel is a .NET Developer, and Microsoft MVP based in Zurich, Switzerland He’s an active maintainer of multiple open-source libraries and is passionate about both sharing and gaining knowledge. If you're into clean code, best practices, and Blazor, Steven is someone you'll want to follow closely. He’s a passionate advocate for writing maintainable, efficient code and dives deep into software development's technical aspects.

Main Content: What I love about Steven’s content is how practical and accessible it is. He has this knack for breaking down complex topics like software architecture and design patterns into actionable .NET tips that you can immediately apply to your projects. His content isnt just educational—its easily digestable must-reads if you’re looking to sharpen your coding skills or enhance your software architecture know-how.

If you're in Zurich, Steven regularly hosts meetups for the local .NET User Group, offering a great opportunity to connect and learn from him in person. He’s also recently launched a video series, which is another fantastic way to dive into his content.

Follow Steven: Blog | LinkedIn

2. Milan Jovanovic

About the Author: Milan Jovanovic is a Software Architect and Microsoft MVP who’s been in the tech industry for years but whose personal content has clearly resonated with the .NET community. Milan is one of those people who genuinely enjoys mentoring others—he’s all about helping software engineers refine their .NET development skills and deepen their understanding of software architecture.

Main Content: Milan’s content is where I go when I need to get my head around architectural principles, microservices, or cloud-native applications. He has a gift for making complex topics feel manageable, no matter where you are in your developer journey. His practical and personable approach makes learning from him both enjoyable and impactful.

Follow Milan: Blog | Twitter | LinkedIn | YouTube

3. Jade Wilson

About the Author: Jade Wilson is a Senior Software Engineer at Microsoft, known for her deep expertise in agile methodologies and DevOps. With a strong passion for building scalable and maintainable solutions, Jade is dedicated to helping customers succeed in delivering high-quality software.

Main Content: What I appreciate most about Jade’s work is how she brings agile and DevOps to life with real-world examples. Her advice is practical and easy to apply, regardless of the project you’re working on. She genuinely believes there’s no single “right” way to deliver software, and that open-mindedness makes her content feel like a conversation with a trusted mentor.

Follow Jade: LinkedIn | YouTube

4. Nick Randolph

About the author: About the Author: Nick Randolph might not be the loudest voice on social media, but he’s a go-to resource for developers interested in Windows and multi-platform development. As a Microsoft MVP, Nick shares his wealth of knowledge in a down-to-earth and approachable way, both on Twitter and through his blog. Whether you're a seasoned pro or just starting out, Nick's insights are always worth the read.

Main Content: Nick blog, "Nick's .NET Travels," is a treasure trove for developers interested in .NET, Windows, and cross-platform development. Covering everything from the latest in Uno Platform to practical guides on mobile and web development, Nick’s posts are designed to help developers navigate the evolving landscape of modern app development and offers a blend of technical depth and real-world applications that make it an essential resource for any developer.

Follow Nick: Website

5. Claudio Bernasconi

About the author: Claudio Bernasconi is a seasoned Software Engineer with over a decade of experience in desktop, mobile, and web development, all with a strong focus on the .NET platform. In addition to his technical expertise, Claudio is passionate about mentoring junior developers and helping them grow their skills.

Main Content: Claudio runs a popular .NET development YouTube channel where he shares his insights on process optimization, code quality, and building sustainable software systems. His content is perfect for developers looking to deepen their understanding of .NET and improve their overall coding practices. Claudio’s approachable style and commitment to quality make him a valuable resource for both new and experienced developers.

Follow Claudio: Twitter | YouTube | LinkedIn

6. Aram Tchekrekjian

About the Author: Aram is a seasoned .NET developer passionate about cloud computing, DevOps, and web technologies. His expertise spans .NET, Web APIs, and Web Security, focusing on cloud-based .NET applications, DevOps practices, and CI/CD pipelines.

Main Content: Aram is great at breaking down complex topics into bite-sized, easily digestible pieces. His carousels are always on point, and his blog, CodingSonata.com, pairs concise explanations of .NET concepts with classical music—how cool is that? Whether you're into cloud-based .NET applications or DevOps practices, Aram's content is as insightful as it is enjoyable.

Follow Aram: Blog | Twitter | LinkedIn

7. Leomaris Reyes

About the Author: Leomaris Reyes has quickly made a name for herself in the .NET community, and it’s easy to see why. As a Microsoft MVP, she’s a passionate advocate for modern software development practices and a strong supporter of women in STEM.

Main Content: Leomaris is the go-to person for anything related to .NET MAUI. Her content is comprehensive, from detailed UI tutorials to advanced coding techniques. If you’re diving into cross-platform development or .NET MAUI, you’ll find her content invaluable.

Follow Leomaris: Blog | Twitter| LinkedIn

8. Martin Zikmund

About the Author: I might be a bit biased since I work with him, but Martin Zikmund’s credentials speak for themselves. He’s a fantastic .NET developer, a Microsoft MVP, and a key contributor to the Uno Platform community—plus, he’s still holding out hope for a Windows phone comeback!

Main Content: Martin’s posts are packed with insights into cross-platform development, especially when it comes to Uno Platform and Windows technologies. His content is clear, accessible, and incredibly useful for developers at any level. If you’re looking to make cross-platform development more straightforward, Martin’s work is where you should start.

Follow Martin: Blog | Twitter | LinkedIn | YouTube

9. Nick Cosentino

About the Author: I recently stumbled onto Nick's content and really took to it. Maybe it's because he is a fellow Canadian, or maybe it is just that his passion resonates in his content. Not just a .NET enthusiast—he’s a passionate open-source contributor and, someone I’m excited to follow.

Main Content: Nick’s work spans a wide range of topics, from .NET performance optimization to open-source contributions. What I really appreciate is how he blends technical insights with the perspective of a software engineering manager. His focus on community engagement and knowledge sharing makes his content both informative and relatable.

Follow Nick: Website | Twitter| LinkedIn | YouTube

10. Oleg Kyrylchuk

About the author: Oleg Kyrylchuk is a software engineer who specializes in .NET technologies and scalable systems. His deep dives into performance tuning and distributed systems are nothing short of impressive.

Main Content: Oleg’s content is all about tackling advanced .NET topics and solving complex technical challenges. If you’re looking to improve your understanding of C# concepts, performance tuning or distributed systems, Oleg’s posts and newsletter are a fantastic resource.

Follow Oleg: Newsletter| Twitter | LinkedIn

I’m sure there are plenty of amazing .NET content creators we didn’t get to cover, so if we missed one of your favorites, drop their names in the comments! We’d love to hear about them.

If you’re looking for even more .NET content creators, I highly recommend the dotnet-content-creators list by Matthias—it’s one of the best and most up-to-date resources for finding creators of all kinds in the .NET community

UnoKeyboard

Joan Magnet — Thu, 22 Aug 2024 16:48:38 +0000

UnoKeyboard is an on-screen keyboard control designed to run on Desktop, WASM, and Windows platforms. It's primarily intended for touch-screen devices.

Features

Cross-platform
Customizable design
Theming support
Custom appearance

Adding the Control to Your Project

The control is available as a NuGet package Nuget package or can be integrated from the GitHub source code.

How should I use the Control?

The keyboard can be used in two different ways:

Using the AddKeyboard extension method
Using a XAML control

If your project uses the default frame navigation, I would recommend using the AddKeyboard extension method. This method automatically shows and hides the keyboard when a TextBox gains or loses focus. On the other hand, if you prefer more control over the keyboard or if you are using other navigation methods, use the XAML control instead.

Using the AddKeyboard Extension Method

The library provides an extension method for the Window class to automatically add the control to your project.

The AddKeyboard method injects a two-row grid. The first row contains a ScrollViewer, and the second row displays the virtual keyboard. The content of the ScrollVieweris assigned to the RootFrameproperty of the McWindowExclass.

Add a reference to McWindowEx.RootFrame in your App.xaml.cs file:

    public static Frame RootFrame => McWindowEx.RootFrame;

Comment out the code that creates the main Frame in the OnLaunched method:

    // Do not repeat app initialization when the Window already has content,
    // just ensure that the window is active
    //if (MainWindow.Content is not Frame rootFrame)
    //{
    //    // Create a Frame to act as the navigation context and navigate to the first page
    //    rootFrame = new Frame();

    //    // Place the frame in the current Window
    //    MainWindow.Content = rootFrame;
    //    rootFrame.NavigationFailed += OnNavigationFailed;
    //}

    //if (rootFrame.Content == null)
    //{
    //    // When the navigation stack isn't restored navigate to the first page,
    //    // configuring the new page by passing required information as a navigation
    //    // parameter
    //    rootFrame.Navigate(typeof(MainPage), args.Arguments);
    //}

Call the AddKeyboardmethod and navigate to the main page:

    // Add UnoKeyboard to the Window
    MainWindow.AddKeyboard(height: 300);

    // Navigate using McWindowEx.RootFrame
    if (RootFrame.Content == null)
    {
        RootFrame.Navigate(typeof(MainPage), args.Arguments);
        RootFrame.NavigationFailed += OnNavigationFailed;
    }

From this point on, the virtual keyboard will automatically appear whenever a TextBoxgains focus.

Using an XAML Control:

Add a reference to the xmlns:ukc="using:UnoKeyboard.Controls" namespace and then add a new control to your file

<ukc:UnoKeyboard x:Name="MyKeyboard"
                 Height="300"
                 Visibility="Collapsed"
                 HandleFocusManager="True" />

Properties

Here are some of the properties. For a complete list, refer to the control's documentation.

Height

This property defines the height of the virtual keyboard. It's important to note that the height of each key depends on the keyboard's height. For example, if the keyboard is 300px high and has 4 rows, each row will be::

(300 - (Padding.Top + Padding.Bottom)) / 4

Similarly, the width of each key is calculated based on the number of keys per row.

HandleFocusManager

If the HandleFocusManagerproperty is set to True, the control will automatically show and hide the virtual keyboard when a TextBox gains or loses focus. Otherwise, the keyboard must be shown and hidden manually.

Keyboard Type

The McWindowExextension class introduces a new attached property: KeyboardType, which allows for keyboard selection. Two default keyboards are available, but you can add more custom keyboards:

en-alfa
numeric

To use a specific keyboard, set the KeyboardTypeattached property on your TextBoxcontrol. The default keyboard is en-alfa:

<Page 
    xmlns:mck="using:UnoKeyboard" />

<TextBox Width="200"
         VerticalAlignment="Center"
         FontSize="30"
         mck:McWindowEx.KeyboardType="numeric" />

Customization

Two static dictionaries are used to define the keyboard and its keys. You can add more keys and keyboard layouts by adding new entries to these dictionaries.

VirtualKeys

The VirtualKeys.Key dictionary dictionary defines the keys that will be displayed on the keyboard. Each key is defined by a VirtualKeyModel.

That is a reduced version of the dictionary:

public static class VirtualKeys
{
    public static Dictionary<string, VirtualKeyModel> Key = new()
    {
        { "N1", new VirtualKeyModel("N1", KeyType.Text, "1", "1", 0x0031, 0x0031, null) },
        { "N2", new VirtualKeyModel("N2", KeyType.Text, "2", "2", 0x0032, 0x0032, null) },
    }
}

For example, to add the | key to your custom keyboard layout:

VirtualKeys.Key.Add("|",                // Dictionary key
    new VirtualKeyModel("|",            // Key ID
                        KeyType.Text,   // Type
                        "|",            // Uppercase
                        "|",            // Lowercase
                        0x007C,         // Unicode uppercase
                        0x007C,         // Unicode lowercase
                        null));         // A Func<Microsoft.UI.Xaml.Shapes.Path>? that returns a Path
                                        // used to draw special keys.

Keyboards

The Keyboards.Keyboard dictionary defines the keyboard layouts. Each keyboard is defined by a KeyboardModel.

Let's add the new key to the keyboard layout:

Keyboards.Keyboard.Add("my_keyboard",   // Dictionary key
    new KeyboardModel("my_keyboard"     // Keyboard Id
                      "1",              // Number of pages.
                      "3",              // Number of rows.
                      "10",             // Max. keys per row.
                      [
                        new KeyModel(0,                     // Page 0
                                     0,                     // Row 0
                                     1,                     // Column 1
                                     1,                     // Column span
                                     VirtualKeys.Get("|")), // Key
                      ]));

For any questions or suggestions, feel free to contact me in the Discussions section or open an Issue on the GitHub repository. You can also find me active in the Uno Platform Discord server.

Everyone is welcome to contribute to the project. Thank you for your interest!

Joan Magnet Sabata

3 productivity tips for .NET developers

mtmattei — Tue, 16 Jul 2024 18:57:35 +0000

The .NET ecosystem provides a variety of tools, and libraries designed to boost your productivity. However, there's invaluable insight to be gained from experienced developers who've honed their skills over the years.

To uncover these tips and tricks, we reached out to some of our seasoned Uno Platform developers. They've generously shared practical advice that has boosted their productivity—and can do the same for you

Dan Siegel - Microsoft MVP
Years of experience: 28 years writing code (14 full-time / professionally)
Dev Environment: Visual Studio on Windows
Favorite Library: Prism

Dan’s Top 3 Productivity Tips:

Step Away: Take breaks away from your computer. Many solutions to complex issues come to mind when you're not actively working on them.
“Honestly, you'd be surprised how many answers/solutions I come up with for things I'm working on when I walk away from the computer and go to lunch. I have even fixed bugs or come up with radical ideas for solving a complex issue while I'm on the dive boat. Software development is a creative process... and many times you need to get away from the computer to let your brain solve problems.
Development is a team sport. No matter how good you think you can make something, you’ll make something better collaborating with someone else. Sometimes, the simple exercise of explaining it to someone else can lead to mind-blowing breakthroughs.
When you’re working with open-source code, don’t be afraid to look at the code. You’d be amazed at how many things you’ll have a better understanding of just by looking at the code, and how many possibilities that will unlock for you.

Follow Dan on: GitHub & Twitter

Martin Zikmund - Microsoft MVP
Years of experience: 15 years
Dev Environment: Visual Studio on Windows
Favorite Library: Uno Platform (of course 😁)

Martin’s Top 3 Productivity Tips:

Invest in workplace: If you have control over your environment, investment into everything you are using while working is a worthwhile investment. This means a quality PC to ensure its performance does not hinder your efficiency; comfortable chair to save your back; standing desk; and ergonomic keyboard and mouse. You are likely spending a lot of time at your PC, so any investments in this regard are worthwhile as they will return to you in both health and time.
Use PowerToys: Don’t get me wrong, Windows is a productive OS out of the box, however, you can make it even better by extending it with useful tools. And one of the best comes directly from Microsoft – PowerToys! It is a set of small modules that enhance the OS in ways that will make it hard to imagine your life without after you integrate it into your workflow. I am currently making a series of videos about this on my YouTube channel, if you want to learn more!
Know your shortcuts: Nothing can speed up your work as much as knowing keyboard shortcuts of your IDE and other apps you use frequently. Just not having to reach for your mouse and being able to keep your hands on the keyboard saves a surprising amount of time! So, find the list of keyboard shortcuts, print it out, and start learning them as you go. My trick to learn faster is to put your mouse on the side of your non-dominant hand for 30 minutes. Just the fact that the mouse is not where you expect it will make force you to think whether using a keyboard shortcut could be better for that specific task!

Follow Martin on: GitHub & Twitter

Steve Bilogan - Microsoft MVP
Years of experience: 8.5 years
Dev Environment: Visual Studio on Windows / VS Code on macOS
Favorite Library: unoplatform/uno.toolkit.ui

Steve’s Top 3 Productivity Tips:

Take a walk, every couple of hours or whenever needed: walk around the block, let your mind wander, decompress, and come back fresh.
Visual Studio CTRL+T Quick Search can search by just the capital letters. Example: Searching for RDP.xaml will resolve properly to RecipeDetailsPage.xaml
Open on GitHub - Visual Studio Marketplace Great extension for quickly opening the highlighted lines in the browser from the GitHub repo. Great for needing to quickly grab the link to lines that you are talking about when communicating on Teams

Follow Steve on: GitHub & Twitter

Youssef Victor - Microsoft MVP
Years of experience: 2 years
Dev Environment: Visual Studio on Windows
Favorite Library: NodaTime, PolySharp

Youssef’s Top 3 Productivity Tips:

Master Keyboard Shortcuts: Learn to use Visual Studio's Quick Search (Ctrl+T) to navigate quickly through both your code and IDE features.
Leverage Multi-Caret Editing: Use your editor's multi-caret functionality in specific situations where it can significantly speed up your editing process. This allows you to edit multiple locations in your code simultaneously.
Consider using grep.app for advanced text searching within your codebase. It offers more powerful search capabilities than the basic search functions within your editor.

Follow Youssef on: GitHub & Twitter

Nick Randolph - Microsoft MVP
Years of experience: 30 years
Dev Environment: Windows (Desktop) + VS
Favorite Library: Moq for mocking interfaces for testing

Nicks Top 3 Productivity Tips:

Better team work through focused, and frequent pull requests.
Release when features are complete rather than try to hit arbitrary deadlines
Don't spin cycles; If you're stuck reach out to someone for help.

Follow Nick on: GitHub & Twitter

Cybertruck in XAML and running Cross-Platform with WebAssembly

Uno Platform — Tue, 03 Dec 2019 15:41:16 +0000

It simply had to be done – Cybertruck in XAML. See for yourself, and further customize the Cybertruck if you’d like, in our WebAssembly implementation of Cybertruck.

Cybertruck XAML

Go ahead, have a swing at its windows with your mouse! Shout out goes to Lynn Fisher whose tweet inspired us to recreate Cybertruck in XAML. Of course we had to add a lil’ Uno logo there on the door.

What is Uno Platform Anyway?

Before getting into the details of Cybertruck in XAML. The Uno Platform enables C# and XAML based code to run on iOS, Android, and WebAssembly. To avoid having to learn the UI-layout techniques and approaches for each platform, the Uno Platform mimics the Windows XAML approach of defining UI and layouts. The Uno Platform does this by providing full API definitions of the Universal Windows Platform and implementations of parts of the API – such as Windows.UI.XAML. Uno Platform is Open Source (Apache 2.0) and available on GitHub. As fans of XAML, and Tesla, it made sense we have some fun with Cybertruck.

How did we do it?

Everything was done in XAML and we mainly used simple controls for the entire content (Grid, Border, Path and a ViewBox to be able to resize the content for all aspect ratios).

For the colors, we used solid ones or LinearGradientBrushes (Horizontal, Vertical or Diagonal).

In terms of animations, we simply used DoubleAnimations, changing the Opacity for the lights or using aRotateTransform for the wheels.

We created every part of the car using vector graphics software in order to create an SVG file, you can use your favorite software package for that part (eg Inkscape, Adobe Illustrator, PaintShop Pro, …).

You will then be able to extract the needed data in the generated SVG file, and use them in the different Path controls inside the content.

How can you customize it?

Having the CyberTruck in action running WebAssembly is pretty cool, but be able to customize it is also fun – https://playground.platform.uno/#cybertruck.

It’s really easy to play around and change the values, here are two examples:

For example, change the CyberTruck color.



BEFORE
<!--MAIN BODY --> <Path Data="M 457.97791,2.8127639 227.25276,82.520113 822.32143,42.553571 Z"> <Path.Fill> <LinearGradientBrush StartPoint="0,0" EndPoint="1,1"> <GradientStop Color="#FFA7A7A7" Offset="0.0" /> <GradientStop Color="#FFDDDDDD" Offset="0.8" /> <GradientStop Color="#FFA7A7A7" Offset="1.0" /> </LinearGradientBrush> </Path.Fill></Path> 

AFTER
<!--MAIN BODY --> <Path Data="M 457.97791,2.8127639 227.25276,82.520113 822.32143,42.553571 Z"       **Fill**** =" ****DeepSkyBlue****"** />

Cybertruck Blue XAML

Or, to make the wheels spin in different direction.



BEFORE
<DoubleAnimation From="0" To="-360" Duration="0:0:0.5" RepeatBehavior="Forever" Storyboard.TargetName="TeslaLeftWheel" Storyboard.TargetProperty="(UIElement.RenderTransform).(RotateTransform.Angle)" />

AFTER 
<DoubleAnimation From="0"** To="360"** Duration="0:0:0.5" RepeatBehavior="Forever" Storyboard.TargetName="TeslaLeftWheel" Storyboard.TargetProperty="(UIElement.RenderTransform).(RotateTransform.Angle)" />

Cybertruck on iOS, Android and Windows

If you’d like to see Cybertruck run cross-platform or iOS, Android and Deslkop too, the code is available for you to compile from Cybertruck – Uno Platform GitHub. Here are a few emulator screen captures.

Cybertruck iOS Cross Platform

Cybertruck Android Tablet Cross Platform

Cybertruck UWP / WinUI

Next Steps

If you want to keep improving this XAML mock–up of the CyberTruck, the code is available at Uno Platform GitHub and we will happily accept contributions.

We’d of course appreciate if you give Uno Platform a try. We have a complete step-by-step tutorial available on GitHub. Or, if you’d prefer something more comprehensive, a full day workshop is also on GitHub.

The post Cybertruck in XAML and running Cross-Platform with WebAssembly appeared first on Uno Platform.

Uno Community Events are Booming this November-December

Uno Platform — Wed, 06 Nov 2019 19:41:47 +0000

The Uno Platform community has been creating quite a buzz as of late. With Microsoft’s recent shout out to Uno and a slew of community events popping up in November and December, Uno Platform is making headlines and introducing user groups to the platform one announcement at a time.

Things that keep us going. Uno community events in November:

– London 🇬🇧

– Orlando 🇺🇸

– Boston 🇺🇸

– Westerville 🇺🇸

– Scottsdale 🇺🇸

– Laval 🇨🇦

– Madrid 🇪🇸

– Malaga 🇪🇸

– Noida 🇮🇳

THANK YOU.#WinUIEverywhere

— Uno Platform #msignite (@unoplatform) November 6, 2019

If you are interested in learning about Uno Platform, check out the events listed below to find one closest to you!

London, GB, UK

Speaker: Matt Lacey and Jay Kannan

Description: Discussing Xamarin/.NET development with an introduction to the Uno Platform!

Date & Time: Wednesday, December 4 – 6:00 pm, 7:30 pm respectively

See the event

Orlando, FL, USA

Speaker: Jerome Laban, CTO of Uno Platform

Description: Developing cross-platform apps for Windows, iOS, Android and WebAssembly can be a complex process, especially when it comes to the user interface. Each platform has its own ways of defining dynamic layouts, with some being more efficient, some more verbose, some more elegant, and some more performant than others.

Luckily, the open-source Uno Platform removes many complexities and enables developers to reuse their existing XAML and C# skills, resulting in a gain of overall productivity when creating UI-rich and data-driven applications. Come learn what the Uno Platform is all about.

Date & Time: Wednesday, November 6 – 6:45 pm

See the event

Burlington, MA, USA

Speaker: Kenzie Whalen

Description: Uno is a new platform that allows developers to write a single codebase and deploy to iOS, Android, UWP, and Web Assembly. In this talk we will go over how Uno works, getting started with your first Uno application, and the future of the Uno Platform.

Date & Time: Saturday, November 23 – 10:15 am

See the event

Westerville, OH, USA

Speaker: Steve Bilogan

Description: “Introduction to Uno”. Learn how the Uno Platform and how it was recently used to bring the official Microsoft UWP Calculator app to the web!

Date & Time: Tuesday, November 5 – 6:30 pm

See the event

Scottsdale, AZ, USA

Speaker: Andres Pineda

Description: An introduction to the Uno Platform from guest speaker, Andres Pineda.

Date & Time: TBD

See the event

Laval, QC, Canada

Speaker: Marie-Christine Leclerc and Alexandre Beauchamp

Description: Developed by nventive in Montreal, Uno is the only platform that allows to develop native applications for mobile, desktop and WebAssembly with C # and XAML from a single code base. It is open source and supported by professionals. In this presentation you will be introduced to Uno Platform and its characteristics.

Join us for this great opportunity to learn about new technologies in a relaxed atmosphere and around a good beer!

Date & Time: Wednesday, November 20 – 6:00 pm

See the event

Madrid, Spain

Speaker: Paulo Vila and Jose Manuel Nieto

Description: In this talk we will introduce Uno Platform. You will discover the revolutionary way to create multi-platform applications and websites in a simpler, more productive and powerful way. We will explain its fundamentals, motivations and its relationship with the UWP (Universal Windows Platform), detailing each of the parts that make up Uno Platform. We will finish with a small hands-on Lab and a technical demo.

Date & Time: Thursday, November 7 – 7:00 pm

See the event

Malaga, Spain

Speaker: Elena Guzman

Description: In this talk we will introduce Uno Platform. You will discover the revolutionary way to create multi-platform applications and websites in a simpler, more productive and powerful way. We will explain its fundamentals, motivations and its relationship with the UWP (Universal Windows Platform), detailing each of the parts that make up Uno Platform. We will finish with a small hands-on Lab and a technical demo.

Date & Time: Friday, November 29 – 10:00 am

See the event

Noida, India

Speaker: Ravi Kumar

Description: Join us as we present our contributions to this year’s Hacktoberfest! We will talk about UNO & some other awesome projects that our meetup members have contributed to. Do not miss out on the chance to learn new frameworks & win some cool SWAG.

Date & Time: Saturday, November 9 – 11:15 am

See the event

If you would like to hold an Uno Platform event in your group/area, check out our Community page and let’s chat!

The post Uno Community Events are Booming this November-December appeared first on Uno Platform.

WinUI on Windows 7 – Yes, it’s possible with Uno Platform

Uno Platform — Wed, 30 Oct 2019 18:52:04 +0000

WinUI is the future of developing beautiful Fluent experiences on Windows 10, Windows 10X and future Windows versions to come. Just as it is important to plan for the future of your Windows development, it is also important to make sure your future UI stack investments are going to be able to run on previous versions of Windows. This is just one of the scenarios Uno Platform can play in making WinUI run everywhere.

About Uno Platform

The Uno Platform enables C# and XAML based code to run on iOS, Android, and WebAssembly. To avoid having to learn the UI-layout techniques and approaches for each platform, the Uno Platform mimics the Windows XAML approach of defining UI and layouts. The Uno Platform does this by providing full API definitions of the Universal Windows Platform and implementations of parts of the API – such as Windows.UI.XAML. Uno Platform is Open Source (Apache 2.0) and available on GitHub.

How it works under the hood

WinUI 3.0 will ship independently of Windows, allowing its features and capabilities to be used on in-market versions of Windows 10. As of today, with Uno Platform WinUI can also run on Windows 7 broadening its reach beyond UWP apps to traditional Win32 applications by utilizing WebAssembly.

Right after //build 2019 we started working together with Microsoft to bring full WinUI XAML support in Uno while Microsoft open sourced it. If you have been paying close attention to Uno GitHub repo you might have noticed some UWP code appear in it. With this tie-in, when using Uno Platform to get your UWP/WinUI 3.0 and later apps on Windows 7 you now have two options for running your app:

Run your app as a PWA. Your Windows 7 will need Chrome installed on it.
Run your app on Chromium through Electron

How is it different than XAML Islands?

XAML Islands enable creation of applications with ‘hybrid UI’. It allows for mixing different UIs from UWP/WinUI, Windows Forms and WPF, allowing developers to gradually modernize older desktop apps with new functionality found in UWP/WinUI. With Uno-built apps you are porting your complete UWP/WinUI application to Windows 7 by using WebAssembly.

Why support Windows 7

Windows 7 extended end of life is January 14, 2020 so why support it?

Windows 7 is going to go down in history as one of the most used and loved operating systems. In a way, it has a similar reputation as the beloved Windows XP. January 2020 is around the corner and it still holds around 30% of the market share according to NetMarketShare or Global Stats statcounter.

While Windows 10 is clearly gaining market share (and we love it), and Windows 7 is on the decline, Windows 7 still has 3x more market share than MacOS.

In addition, in our quick Twitter survey we discovered that 22% of the developers we polled have a need to target Windows 7 as their deployment OS beyond the end of support date, some 12% even targeting for at least 3 more. A similar survey on CodeProject unveiled that over 33% of the developers polled there plan to target Windows 7 past its end of support date.

The estimated size of .NET developer community size is around 3-4 million developers. Given the poll stats above, there are at least 1,000,000 reasons why we think it is important to provide support for Windows 7 and help put WinUI Everywhere.

Uno Platform in Enterprise Scenarios and on Windows 7

We think WebAssembly is ready for prime time. We’ve had great experiences working with customers modernizing their rich internet/web applications with hundreds of screens with charts and grids, etc. One of our customers, HubSE, has been using Uno to modernize their LOB applications and they saved 10x the time in the process. Also, to try Uno’s support for WinUI on Windows 7, we ported our UADO (Universal Azure Dev Ops) app to Windows 7 and to our delight it works just great. UADO currently runs on iOS, Android, WebAssembly, Windows Store and now on Windows 7 as well. Try UADO in any of those scenarios, compare the performance and you will be a believer as well.

Sample UWP/WinUI application running on Windows 7 via WebAssembly

In closing

We are very proud to have had the opportunity to help in this way. This work and the access Microsoft gave us has helped us out tremendously to both deliver on the ‘WinUI everywhere’ promise, as well as to accelerate Uno development itself. For example, just having access to unit tests for UWP has accelerated our development by 3x. It is a great benefit to complete developer community and another result of what the ‘new open Microsoft’ is capable of.

We’d appreciate your feedback in using Uno Platform. Try Uno Platform now and reach out to us on Gitter with any feedback. #WinUIEverywhere

Get Started

We are happy to be covering this crucial need for Windows developers and we hope to bring all of you 10x time savings like we did with HubSE and join the rest of our happy customers.

The post WinUI on Windows 7 – Yes, it’s possible with Uno Platform appeared first on Uno Platform.

Dark Mode and MarkupExtensions now available in Uno Platform

Uno Platform — Mon, 28 Oct 2019 13:14:46 +0000

In the past few weeks we’ve had a couple big additions to Uno Platform which you should be aware of as your Uno development just got easier – and cooler.

Dark Mode by @mzikmunddev

Uno Platform Dark Mode by @mzikmunddev

You have probably heard of ‘dark mode’ – a UI option which displays light text on a dark background, as opposed to the default dark text on a light background. The reduced brightness of the screen has brought many benefits – such as courtesy in situations when a screen’s bright light creates a distraction (i.e. movie theatres). Also, users report it reduces strain on their eyes when using the ‘dark mode’. Finally, ‘dark mode’ has great advantages for the battery lifetime of your devices. Now, Uno Platform supports ‘dark mode’ as well!

Thanks to the introduction of {ThemeResource} markup extension by Uno Platform core team member, Carl de Billy, you can add the Dark and High Contrast themes and automatic OS dark/light theme detection capability when the Application.RequestedTheme is not specified. The ‘dark mode’ works on iOS, Android, Windows and WebAssembly (WASM). Your app can now switch to dark theme automatically, without any additional code! The user will be able to switch between light and dark mode of your app the same way as all other applications – via Settings on their device.

MarkupExtensions by @ cacchiom

MarkupExtensions were a great feature of WPF, and as of Windows 10 build 16299, they have been available to UWP developers to use in their own apps.

In XAML applications, markup extensions are a method/technique to gain a value that is neither a specific XAML object nor a primitive type. Markup extensions can be defined by opening and closing curly braces and inside those curly braces, the scope of the markup extension is defined.

As Xaml developers, we’ve come across MarkupExtensions very often since some of them we use on a regular basis: {Binding} {StaticResource} {x:Bind} {x:Null}. But now with support for creating your own, developers have more flexibility in their Xaml code by creating custom MarkupExtensions to suit their needs.

Here’s a very simple example of creating one:

namespace MyApp.MarkupExtensions
{
    [MarkupExtensionReturnType(ReturnType = typeof(string))]
    public class CustomString : Windows.UI.Xaml.Markup.MarkupExtension
    {
        public string MyString { get; set; }

        public int MyNumber { get; set; }

        protected override object ProvideValue()
        {
            return $"{MyString ?? string.Empty} AND #{MyNumber}";
        }
    }
}

And then in your Xaml:

xmlns:ext="using:MyApp.MarkupExtensions"
.
.
.
<TextBlock Text="{ext:CustomString MyString='Simple text', MyNumber=999}" />

Starting with **Uno.UI 2.0.275-dev.2987**, developers can now embrace this useful feature in their Uno apps and strengthen their Xaml. We hope you enjoy this new feature as we continue to improve on the capabilities of the Uno Platform.

The post Dark Mode and MarkupExtensions now available in Uno Platform appeared first on Uno Platform.