Friday, May 18, 2018

UWP Tip #19 - The Windows Community Toolkit

Hello UWP developers!

We take a quick break from our UWP Community Toolkit tips series because the toolkit has been given a new name this month! The UWP Community Toolkit is now called the Windows Community Toolkit.

The new name is a reflection of the renewed focus of the project - enabling Windows developers to quickly build awesome applications for Windows 10. The scope of the toolkit will be broadening to encompass controls, components and helpers for UWP, WPF, WinForm, Xamarin.Form and more. Long story short, if you are building for Windows and can consume a .NET Standard library, the Windows Community Toolkit aims to help you succeed.

Everything has been renamed - the documentation and the GitHub repository for now, and soon the sample app.

The next major update of the toolkit (v3.0) is coming soon. If you take a look at the milestones on GitHub, there's a code freeze for 3.0 on May 23rd and the target date for the release is May 30th. I see some interesting features in the list of issues for this release including a dark theme for the sample app and an InfiniteCanvas control.

Go check out the announcement on the Windows Developer Blog from earlier this month to get all the information about the name change. As soon as the new release is out, I'll be back with some more tips and tricks for using the new controls and helpers.

If you want to help build the toolkit, check out the list of open issues and submit a PR!


Friday, April 27, 2018

Microsoft Build 2018 - Interesting Sessions for Windows Developers

Microsoft Build 2018 is coming in just a few days, and the sessions have been published. While I am unable to attend this year, I plan to watch the keynote live and many of the other recorded sessions later in the week.

I decided to browse the session listings and start building a list of the ones that interest me as a Windows developer. Here is what I have so far, in no particular order.

THR2407-1 - Amazing experiences and how to build them – from the people building showcases and demos - Part 1
and
THR2407-2 - Amazing experiences and how to build them – from the people building showcases and demos - Part 2

Microsoft technologies enable end to end experiences that help you build successful solutions to empower your users at home and at work. Presented in the #ifdef WINDOWS format, this zero-slide, fast paced demo session will show you why and how some of these new technologies such as Microsoft Graph, Progressive Web Apps, Fluent Design, Windows Machine Learning, Mixed reality, new cloud services (and much more) can work together to extend your application to reach new users and increase user productivity. Watch the promo here.

TSP2107 - Bringing cloud powered UI to Windows 10 XAML applications

The Windows 10 platform team is exploring the developer landscape of bringing cloud powered UI content natively to Windows 10 applications and how ReactNative as a model fits into that overall story. We would like to share some early sneak peaks and get your feedback on what you would like to see as platform investments in this space.

BRK3503 - Creating Innovative Experiences for Fluent Design using the Visual Layer

Explore how to create engaging Windows applications by incorporating effects, animations, and new types of content that form the building blocks for the Fluent Design System. This session showcases new platform capabilities that enable you to craft innovative 2D and 3D experiences using volumetric objects, vector graphics, depth, motion, lights, and materials. Learn how to bring differentiated UI to your application, tailored for a wide range of Windows devices.

TSP2108 - Open source and backward compatibility for the Windows 10 XAML framework

The Windows 10 platform team is considering updating our engineering process to release parts of the Windows 10 XAML / Fluent UI framework as open source packages that provide backward compatibility for a wider range of Windows 10 versions. We would like to share some options we’re considering and get feedback on what would be most useful to you.

TSP2109 - What could be next for the Windows Community Toolkit

The Windows Community Toolkit continues to grow, with packages that extend to new areas of Windows development being added with each new release. Join us as we envision where else we can partner with the community and what could the toolkit do in 6 months and beyond.

BRK2423 - What's New for Windows UX Developers: Fluent and XAML

Join us for a lap around the new innovations coming to the Windows ux platform this year. Catch up on the latest UWP APIs and how you can use familiar technologies like XAML and C# to build experiences that leverage the Fluent Design System to captivate your customers and maximize their productivity. This must-see session will cover improvements in ux fundamentals; new controls for navigation, commanding, collections, and forms; enhancements to developer productivity; and more!

TSP2112 - Windows Template Studio

Windows Template Studio continues to add new features and abilities. We're always looking to help prioritize and validate big work items such as additional frameworks and platforms. Join us as we envision where else we can partner with the community and what could the toolkit do in 6 months and beyond.

BRK2401 - Adaptive Cards in Bots, Windows, Outlook and your own applications

Adaptive Cards is a new, simple yet highly capable declarative format that makes it a breeze to display rich card-like interfaces in any application. Learn how Bots, Windows and Outlook use the power of Adaptive cards to showcase information from applications like yours. Using the same technology, your application can do the same to help create interactive and actionable experiences that are both engaging and can simplify business processes across your organization.

TSP2101 - Build hybrid applications faster and better on Windows

This sessions explores the patterns, tools and frameworks that developers utilize to build Hybrid Applications on Windows. We will talk about the platform and tooling updates we could potentially make to improve the overall Hybrid App development experience on Windows. If you are a desktop app developer leveraging a combination of technology stacks like web, native (UWP, WPF), React, etc. , stop by and share your thoughts on what we can do to help you be more productive.

BRK2412 Developing for Sets on Windows 10

Sets helps users be more productive by helping them to focus better and to pick up where they left off. Learn how Windows automatically integrates your apps with Sets to help users be more productive, and learn about opportunities to enrich your Windows applications to provide even more engaging experiences through User Activities, branded tab visuals, and new windowing features. Make your applications amazing in Sets!

BRK2413 Fluent Design: Evolving our Design System

Microsoft has continued to evolve the Fluent Design System’s set of controls, patterns, principles and design guidance since its debut at Build 2017. Get a hands-on look at how 1st-party Microsoft experiences are taking advantage of the system and empowering their users to achieve more by crafting experiences that are natural on each device, intuitive, powerful, engaging, and immersive. Come learn how you can build experiences with the latest Fluent Design features to help your users do more in our multi-device, multi-sensory world.

BRK3501 Modernizing Desktop Apps on Windows 10

Come learn about the future of your WPF & Windows Forms applications. Windows, .NET and Visual Studio are making it easy to incrementally modernize your existing applications with Windows 10 features. Containerize your application for compatibility and installation isolation and begin integrating new Windows 10 UI features with just a few clicks in Visual Studio. Modern applications are deeply connected to the people you work with and know which devices you’re using. We will cover the ways the Microsoft Graph allow your existing application to connect users and help them complete tasks as well.

BRK2432 MSIX: Inside and Out

MSIX is the future of app installation building on top of and fully compatible with existing appx mechanisms. It provides a cross-platform, down level compliant, enterprise class installer with benefits ranging from existing LOB apps, distribution through the Microsoft Store, Store for Business, or other custom distribution methods. Come see why MSIX brings the best of MSI, Click Once, App-V and APPX together for your customers and business.

THR3306 Tying it all together – Modernizing Enterprise Applications

Enterprise developers face many challenges in today's environment as many applications are planning for capabilities and growth via the cloud.  This session will show you how to make sure your application is architected to continue working on the desktop on-prem as well as move to the cloud and easily add new device endpoints when you are ready.  We will also cover new tooling in VS that helps you start new projects on the right track or update existing probjects with containers, REST interfaces, and accessing data in the cloud.

...and a few to indulge my Mac and Xamarin interests.


THR2021 Visual Studio for Mac Tips & Tricks

Visual Studio for Mac is the Microsoft IDE natively designed for the Mac. You get everything you need for mobile, web, game and cloud development with C# and F#, with rich support for Xamarin, .NET Core, Unity and Azure development. In this session, come hang out with Jordan as he takes you through tips and tricks to help you get the most out of Visual Studio for Mac. This one's for beginners and experts alike!

BRK2152 What's new with Visual Studio for Mac

Visual Studio for Mac launched last year at Build as the Microsoft IDE natively designed for the Mac. Since then, regular releases have added improvements and features for .NET Core 2.0, Azure Functions, Docker, and more. Join us in this session to get a whirlwind tour of what is new and also learn about what’s coming in Visual Studio for Mac to make .NET developers even more productive on the Mac.

BRK2437 - What’s new in Xamarin.Forms 3.0

Xamarin.Forms enables you to build a native UI for multiple platforms with one shared C# and XAML codebase. Simply put, if you know C# then you already know how to build Android, iOS, and Windows apps. In this session come find out what is new, next, and absolutely awesome in Xamarin.Forms 3.0.

If you're not attending Build this year, be sure to catch it online. If you are attending live in Seattle, then I'm super-jealous! Enjoy your week of learning and networking!


Friday, March 30, 2018

UWP Tip #18 - UWP Community Toolkit - Part 15, Markdown Parser

Welcome back to my UWP Community Toolkit series. The previous five tips in the series can be found here:

Intro

As I mentioned in my last post, Part 14, the UWP Community Toolkit includes a pair of helper classes for parsing, one for parsing RSS data and the other for parsing markdown. Let's take a look into the Markdown Parser helper this time.

Markdown Parser

The Markdown parser includes a helper class to take a markdown string, parse it into a Markdown Document and then render that document into your UWP controls with a Markdown Renderer.
(Tip: The toolkit's MarkdownTextBlock also uses the MarkdownDocument and MarkdownRenderer classes. When you use the control, you can use this default renderer or set your own that overrides the MarkdownRendererBase.)
The UWP Community Toolkit Sample App includes this simple example of the Markdown Parser in action.

UWPmarkdownparser1

In this example, you see the raw markdown "This is **Markdown**". That text was parsed into a MarkdownDocument. The document was then serialized to JSON and displayed in a TextBlock. Here is that code from the sample app:

private void UpdateMDResult()

{
     var document = new MarkdownDocument();
     document.Parse(RawMarkdown.Text);
    var json = JsonConvert.SerializeObject(document, Formatting.Indented, new StringEnumConverter());
     MarkdownResult.Text = json;

}

You can see that creating the document is as simple as instantiating a new MarkdownDocument and calling Parse with your raw text. Once you have a MarkdownDocument, you can very easily manipulate it to add, modify or remove individual blocks or elements. The document is essentially a list of markdown blocks. In fact, the sole property you need to be concerned with on MarkdownDocument is Blocks (an IList<MarkdownBlock>).

Objects that derive from MarkdownBlock are MarkdownDocument or one of the following block types:
  • CodeBlock
  • HeaderBlock
  • HorizontalRuleBlock
  • LinkReferenceBlock
  • ListBlock
  • ParagraphBlock
  • QuoteBlock
  • TableBlock
The purpose of each type is fairly self-explanatory. If you need to manipulate one of these blocks, you would find the target block in the Blocks list and add/remove/modify/replace it, as necessary. Let's take a closer look at the LinkReferenceBlock. This block consists of the following properties to hold the link information:
  • Id - A unique string id to identify the reference link.
  • Tooltip - The link's tooltip to be displayed when rendered.
  • Url - The target.
  • Value - The text value to display for the link.
  • Type - This is inherited from the MarkdownBlock base and would return the type of this particular block.
I would encourage you to explore the other block types on GitHub if you plan on implementing your own renderer or markdown control.

Wrap-Up

I encourage you to explore the Markdown Parser on MS Docs and GitHub when you have a chance. If you have any ideas to enhance this parser or any part of the toolkit, submit an issue or submit a pull request.

Happy coding!

Friday, March 16, 2018

UWP Tip #17 - UWP Community Toolkit - Part 14, RSS Parser

Welcome back to my UWP Community Toolkit series. The previous five tips in the series can be found here:

Intro

The toolkit now includes two helper classes for parsing, one for parsing RSS feed data and the other for parsing markdown. These parsers simplify working with each of these formats. Today we will examine the RSS Parser helper.

RSS Parser

The RSS Parser helper consists of two classes. An RssParser which takes RSS feed data and does the parsing into a list of feed items. The RssParser has a parameterless constructor and a single Parse method which takes the feed data as a string and returns an IEnumerable<RssSchema>.

RssSchema is the other class included with the helper and is the representation of a feed item. The RssSchema has a parameterless constructor and the following properties:
  • Author
  • Content
  • ExtraImageUrl
  • FeedUrl
  • ImageUrl
  • MediaUrl
  • PublishDate
  • Summary
  • Title
If you are familiar with RSS data, these properties should all be familiar. Each is a string type except for PublishDate, which is a DateTime.

I created a simple static helper method which takes a string containing feed data returned from an HttpClient call and returns a list of feed items (RssSchema).

public static IList<RssSchema> ParseRssFeed(string feed)
{
     if (string.IsNullOrWhiteSpace(feed))
     {
         throw new ArgumentException("Feed cannot be empty.", nameof(feed));
     }
     var parser = new RssParser();
     var rssItems = parser.Parse(feed).ToList();

     // Loop to illustrate some of the available properties
     foreach (var item in rssItems)
     {
         Debug.WriteLine($"Title: {item.Title}");
         Debug.WriteLine($"Author: {item.Author}");
         Debug.WriteLine($"Summary: {item.Summary}");
     }
     return rssItems;
}

The foreach loop is unnecessary unless you were actively debugging an issues with a particular feed being parsed. The method could end before the loop with:

return parser.Parse(feed).ToList();

Wrap-Up

There isn't much to explain with this helper. It saves you a bit of parsing and provides a class representation of a feed item. While it is a simple helper, the RSS Parser is particularly interesting to me. I am always looking for ways to leverage RSS data to improve the workflow for creating blog posts for my other blog, the Morning Dew. The UWP companion app for that blog is rather basic and sorely in need of a refresh. Helpers like these provide a little extra motivation to go out and make some progress on Morning Dew UWP vNext.

Go check out the source and give the RSS Parser a try today!

Happy coding!

del.icio.us Tags: ,

Sunday, February 18, 2018

UWP Tip #16 - UWP Community Toolkit - Part 13, the Loading… Control

Welcome back to my UWP Community Toolkit series. The previous five tips in the series can be found here:
Here's a quick tip about a straightforward but useful control. The UWP Community Toolkit has a Loading control to indicate that your UWP app is currently loading some content. Drop this into your Page or Control and make it visible when data is loading and you want to prevent users from interacting with the application.

I created a Page with a Grid containing a ListBox and a Loading control. The ListBox gets loaded with a list of animals during load and the Loading control has its IsLoading property set to true. This is the property you would normally toggle on and off while a long-running load process is occurring. Here's a look at the XAML:

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
     <ListBox x:Name="MainItemsList"/>
    <controls:Loading x:Name="MainLoadingControl" HorizontalContentAlignment="Center" 
                       VerticalContentAlignment="Center" Background="DarkGray" Opacity="0.8">
         <StackPanel Orientation="Horizontal" Padding="8">
             <ProgressRing IsActive="True" Margin="0,0,10,0" Foreground="CadetBlue" />
             <TextBlock Text="Loading control with wait ring. Loading..." VerticalAlignment="Center" Foreground="White"/>
         </StackPanel>
     </controls:Loading>
</Grid>

Inside the Loading control, you can set any content you want to display for your users during the wait interval. I've chosen a horizontal StackPanel with a ProgressRing and TextBlock. Of course, a production app would probably move the content of this panel into a shared resource that could dynamically set the text of the TextBlock based on the current context of the wait/load period.

This is the code from the Page's code behind file to load the list items and display the loading panel.

private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
     var listItems = new List<string>
     {
         "Item 1 - Dog",
         "Item 2 - Hamster",
         "Item 3 - Rat",
         "Item 4 - Cat",
         "Item 5 - Lizard",
         "Item 6 - Guinea Pig",
         "Item 7 - Snake",
         "Item 8 - Turtle",
         "Item 9 - Bird",
         "Item 10 - Gerbil",
         "Item 11 - Mouse",
         "Item 12 - Fish"
     };
    MainItemsList.ItemsSource = listItems;
    MainLoadingControl.IsLoading = true;
}

Again, best practices outside of a sample app would have these list items inside an ObservableCollection in the corresponding view model. The IsLoading property would also be bound to a boolean in your view model to be toggled on/off as necessary.

This is the end result of our basic list behind a Loading control.

UWPToolkit-LoadingControl1

It looks pretty slick for a few lines of code in a sample app. Go download the latest Toolkit in your UWP app and give it a try today. The GitHub source for the control can be found here.

Happy coding!

Technorati Tags: ,