company_banner
  • Get Moving with Xamarin.Forms 4.4

      We were speaking with a customer last year that builds dozens of mobile applications every year. They said, «We cannot remember the last time we made a mobile app that did NOT include a carousel view.» Many of you have expressed almost identical sentiments to us. So, we are very pleased to introduce a new CarouselView control in Xamarin.Forms 4.4.0. Along with this we also have IndicatorView for displaying the pages or items in the carousel. As well as SwipeView for providing contextual actions to any element in a CollectionView. The release theme of getting things moving would not be complete without showcasing the new GIF animation support for images. Let’s begin right there.

      Read more →
    • Demystifying the new .NET Core 3 Worker Service

        Premier Developer Consultant Randy Patterson discusses the benefits of using the new Worker Service project template introduced in .NET Core 3.

        .NET Core 3 introduced a new project template called Worker Service. This template is designed to give you a starting point for cross-platform services. As an alternate use case, it sets up a very nice environment for general console applications that is perfect for containers and microservices.



        Some of the benefits of using this template include the following areas.

        Read more →
      • A Second Year of Q#

          You can see all of the release notes for the year here.

          Remember How We Started


          Our first release of our second year, 0.4, was a triumph! we got a customer request for a big integer type on January 1st, and were able to respond by shipping a new BigInt data type just 29 short days later!!! Remember, we’re outside Seattle, pretty far north, so our winter days are really short.

          Our secret? We had started working on the BigInt type in December.

          We also decided to change our release cadence for our second year of Q#. Our first year, we had shipped releases sporadically, when we had some major feature to share, or possibly just a fix to an annoying bug. For our second year, we moved to a more regular release cadence, putting out a new release every month. We hoped that this would make things more predictable for our users and easier for us to manage.

          Read more →
        • Learn Azure in a Month of Lunches — our new free e-book

            More than 100 Azure services offer everything you need to build and run your applications with all the performance, redundancy, security, and scale that the cloud has to offer. But knowing where to begin with all these services can seem overwhelming. 

            Read this e-book to build your cloud computing skills quickly and efficiently. You’ll be productive immediately, and when you finish, you’ll be well on your way to Azure mastery. 

            Learn more below.


            Read more →
          • Announcing .NET Core 3.1

              We’re excited to announce the release of .NET Core 3.1. It’s really just a small set of fixes and refinements over .NET Core 3.0, which we released just over two months ago. The most important feature is that .NET Core 3.1 is an long-term supported (LTS) release and will be supported for three years. As we’ve done in the past, we wanted to take our time before releasing the next LTS release. The extra two months (after .NET Core 3.0) allowed us to select and implement the right set of improvements over what was already a very stable base. .NET Core 3.1 is now ready to be used wherever your imagination or business need takes it.

              You can download .NET Core 3.1, for Windows, macOS, and Linux:


              ASP.NET Core and EF Core are also being released today.

              Visual Studio 2019 16.4 was also released today and includes .NET Core 3.1. It is a required update to use .NET Core 3.1 with Visual Studio. For Visual Studio 2019 users, we recommend simply updating Visual Studio to 16.4 and instead of separately downloading .NET Core 3.1.

              Visual Studio for Mac also supports and includes .NET Core 3.1, in the Visual Studio for Mac 8.4 Preview channel. You will need to opt into the Preview channel to use .NET Core 3.1.

              Release notes:



              Read more →
            • Windows Terminal Preview v0.7 Release

                Another release is out for the Windows Terminal preview! This release is labeled as v0.7 in the About section of the Terminal. As always, you can download the Terminal from the Microsoft Store and from the GitHub releases page. Here’s what’s new in this release:

                Windows Terminal Updates


                Panes


                You are now able to split your Terminal window into multiple panes! This allows you to have multiple command prompts open at the same time within the same tab.

                Note: At the moment, you’re only able to open your default profile within a new pane. Opening a profile of your choice is an option we’re planning to include in a future release!



                Read more below.
                Read more →
              • AI-assisted IntelliSense for your team’s codebase

                  Visual Studio IntelliCode uses machine learning to offer useful, contextually-rich code completion suggestions as you type, allowing you to learn APIs more quickly and code faster. Although IntelliCode’s base model was trained on over 3000 top open source C# GitHub repositories, it does not include all the custom types in your code base. To produce useful, high-fidelity, contextually-rich suggestions, the model needs to be tailored to unique types or domain-specific APIs that aren’t used in open source code. To make IntelliSense recommendations based on the wisdom of your team’s codebase, the model needs to train with your team’s code.

                  Earlier this year, we extended our ML model training capabilities beyond our initial Github trained base model to enable you to personalize your IntelliCode completion suggestions by creating team models trained on your own code.

                  Read more →
                • Building Modern Cloud Applications using Pulumi and .NET Core

                    We are excited to announce .NET Core support for Pulumi! This announcement means you can declare cloud infrastructure — including all of Azure, such as Kubernetes, Functions, AppService, Virtual Machines, CosmosDB, and more — using your favorite .NET language, including C#, VB.NET, and F#. This brings the entire cloud to your fingertips without ever having to leave your code editor, while using production-ready «infrastructure as code» techniques.

                    Read more →
                  • Cool WSL (Windows Subsystem for Linux) tips and tricks

                      It's no secret I dig WSL (Windows Subsystem for Linux) and now that WSL2 is available in Windows Insiders Slow it's a great time to really explore the options that are available. What I'm finding is so interesting about WSL and how it relates to the Windows system around it is how you can cleanly move data between worlds. This isn't an experience you can easily have with full virtual machines, and it speaks to the tight integration of Linux and Windows.

                      Look at all this cool stuff you can do when you mix your peanut butter and chocolate!

                      Read more →
                    • ML.NET Model Builder Updates

                        ML.NET is a cross-platform, machine learning framework for .NET developers, and Model Builder is the UI tooling in Visual Studio that uses Automated Machine Learning (AutoML) to easily allow you to train and consume custom ML.NET models. With ML.NET and Model Builder, you can create custom machine learning models for scenarios like sentiment analysis, price prediction, and more without any machine learning experience!

                        ML.NET Model Builder


                        This release of Model Builder comes with bug fixes and two exciting new features:

                        • Image classification scenario – locally train image classification models with your own images
                        • Try your model – make predictions on sample input data right in the UI

                        Read more →
                      • .NET Core with Jupyter Notebooks Preview 1

                          When you think about Jupyter Notebooks, you probably think about writing your code in Python, R, Julia, or Scala and not .NET. Today we are excited to announce you can write .NET code in Jupyter Notebooks.

                          Try .NET has grown to support more interactive experiences across the web with runnable code snippets, interactive documentation generator for .NET core with dotnet try global tool, and now .NET in Jupyter Notebooks.

                          Read more →
                        • Announcing .NET Core 3.1 Preview 2

                            We’re announcing .NET Core 3.1 Preview 2. .NET Core 3.1 will be a small and short release focused on key improvements in Blazor and Windows desktop, the two big additions in .NET Core 3.0.. It will be a long term support (LTS) release with an expected final ship date of December 2019.

                            You can download .NET Core 3.1 Preview 2 on Windows, macOS, and Linux.


                            ASP.NET Core and EF Core are also releasing updates today.

                            Visual Studio 16.4 Preview 3 and Visual Studio for Mac 8.4 Preview 3 are also releasing today. They are required updates to use .NET Core 3.1 Preview 2. Visual Studio 16.4 includes .NET Core 3.1, so just updating Visual Studio will give you both releases.

                            Details:


                            Read more →
                          • .NET Core 3 for Windows Desktop

                              In September, we released .NET Core support for building Windows desktop applications, including WPF and Windows Forms. Since then, we have been delighted to see so many developers share their stories of migrating desktop applications (and controls libraries) to .NET Core. We constantly hear stories of .NET Windows desktop developers powering their business with WPF and Windows Forms, especially in scenarios where the desktop shines, including:

                              • UI-dense forms over data (FOD) applications
                              • Responsive low-latency UI
                              • Applications that need to run offline/disconnected
                              • Applications with dependencies on custom device drivers

                              This is just the beginning for Windows application development on .NET Core. Read on to learn more about the benefits of .NET Core for building Windows applications.

                              Read more →
                            • Introducing Orleans 3.0

                                This is a guest post from the Orleans team. Orleans is a cross-platform framework for building distributed applications with .NET. For more information, see https://github.com/dotnet/orleans.

                                We are excited to announce the Orleans 3.0 release. A great number of improvements and fixes went in, as well as several new features, since Orleans 2.0. These changes were driven by the experience of many people running Orleans-based applications in production in a wide range of scenarios and environments, and by the ingenuity and passion of the global Orleans community that always strives to make the codebase better, faster, and more flexible. A BIG Thank You to all who contributed to this release in various ways!

                                Read more →
                              • SpaceFusion: Structuring the unstructured latent space for conversational AI

                                  A palette makes it easy for painters to arrange and mix paints of different colors as they create art on the canvas before them. Having a similar tool that could allow AI to jointly learn from diverse data sources such as those for conversations, narratives, images, and knowledge could open doors for researchers and scientists to develop AI systems capable of more general intelligence.


                                  A palette allows a painter to arrange and mix paints of different colors. SpaceFusion seeks to help AI scientists do similar things for different models trained on different datasets.
                                  Read more →
                                • Upcoming SameSite Cookie Changes in ASP.NET and ASP.NET Core

                                    SameSite is a 2016 extension to HTTP cookies intended to mitigate cross site request forgery (CSRF). The original design was an opt-in feature which could be used by adding a new SameSite property to cookies. It had two values, Lax and Strict.

                                    Setting the value to Lax indicated the cookie should be sent on navigation within the same site, or through GET navigation to your site from other sites. A value of Strict limited the cookie to requests which only originated from the same site. Not setting the property at all placed no restrictions on how the cookie flowed in requests. OpenIdConnect authentication operations (e.g. login, logout), and other features that send POST requests from an external site to the site requesting the operation, can use cookies for correlation and/or CSRF protection. These operations would need to opt-out of SameSite, by not setting the property at all, to ensure these cookies will be sent during their specialized request flows.

                                    Google is now updating the standard and implementing their proposed changes in an upcoming version of Chrome. The change adds a new SameSite value, «None», and changes the default behavior to «Lax». This breaks OpenIdConnect logins, and potentially other features your web site may rely on, these features will have to use cookies whose SameSite property is set to a value of «None».

                                    However browsers which adhere to the original standard and are unaware of the new value have a different behavior to browsers which use the new standard as the SameSite standard states that if a browser sees a value for SameSite it does not understand it should treat that value as «Strict». This means your .NET website will now have to add user agent sniffing to decide whether you send the new None value, or not send the attribute at all.

                                    Read more →
                                  • Now is the time to make a fresh new Windows Terminal profiles.json

                                      I've been talking about it for months, but in case you haven't heard, there's a new Windows Terminal in town. You can download it and start using it now from the Windows Store. It's free and open source.

                                      At the time of this writing, Windows Terminal is around version 0.5. It's not officially released as a 1.0 so things are changing all the time.

                                      Here's your todo - Have you installed the Windows Terminal before? Have you customize your profile.json file? If so, I want you to DELETE your profiles.json!

                                      Read more →
                                    • Blazor Server in .NET Core 3.0 scenarios and performance

                                        Since the release of Blazor Server with .NET Core 3.0 last month lots of folks have shared their excitement with us about being able to build client-side web UI with just .NET and C#. At the same time, we’ve also heard lots of questions about what Blazor Server is, how it relates to Blazor WebAssembly, and what scenarios Blazor Server is best suited for. Should you choose Blazor Server for your client-side web UI needs, or wait for Blazor WebAssembly? This post seeks to answer these questions, and to provide insights into how Blazor Server performs at scale and how we envision Blazor evolving in the future.

                                        What is Blazor Server?


                                        Blazor Server apps host Blazor components on the server and handle UI interactions over a real-time SignalR connection. As the user interacts with the app, the UI events are sent to the server over the connection to be handled by the various components that make up the app. When a component handles a UI event, it’s rendered based on its updated state. Blazor compares the newly rendered output with what was rendered previously and send the changes back to the browser and applies them to the DOM.

                                        Read more →