Disclaimer: this is an automatic aggregator which pulls feeds and comments from many blogs of contributors that have contributed to the Mono project. The contents of these blog entries do not necessarily reflect Xamarin's position.

May 26

Podcast: Previewing Xamarin.Forms 3.0

In this episode of the Xamarin Podcast, I’m joined by Xamarin.Forms PM David Ortinau to walk through the early preview of Xamarin.Forms 3.0 announced at Microsoft Build 2017. Learn about new ways you can use Xamarin.Forms in your apps, speed and performance enhancements, and what new platforms are coming to Xamarin.Forms. Be sure to download today’s episode from your favorite podcasting app!



Subscribe or Download Today

Keeping up with the latest in .NET, C#, and Xamarin is easier than ever with the Xamarin Podcast! Cohosts Pierce Boggan and James Montemagno cover topics relevant to Xamarin developers, from designing mobile apps to identity management. Be sure to subscribe to the Xamarin Podcast on iTunes, Google Play Music, Stitcher, or your favorite podcast app you use to ensure you don’t miss an episode.

The post Podcast: Previewing Xamarin.Forms 3.0 appeared first on Xamarin Blog.

May 25

TrainerRoad Helps Cyclists Increase Performance with Five-Star Apps

The .NET community continues to grow in size and expertise, ranging from recent college grads building the future of technology to experienced professional developers modernizing decades’ old business processes. TrainerRoad,one of our amazing customers, combines their passion for technology with their passion for cycling. They’re laser-focused on user experience, delivering web, mobile, and desktop apps that provide personalized workouts and training plans, connect with on-bike sensors to track performance metrics, electronically readjust resistance, and sync real-time metrics across platforms.

Today, Nate Pearson, TrainerRoad CEO, shares how his team uses end-to-end mobile DevOps and cloud services to build, test, distribute, and continuously monitor and improve their apps to ensure their customers get the same high performance and quality from their training technology that they demand from their own performance. The result? Five-star ratings and a rapidly growing user base.

Tell us a little bit about your company and role. Have you always been a developer?

Becoming a faster cyclist used to be my personal mission and it inspired me to build TrainerRoad. I used to wake up and spend my days creating executive dashboards for a Fortune 500 slot machine manufacturer, but all my free time—weekends, early-morning hours before my 8-to-5 engineering job, and late-night evenings after my kids went to bed—was dedicated to triathlon training and increasing my speed. Your bike (and your training regime) is where you make up the most time: if you’re strong on your bike, you finish with a time you’re proud of.

Now, I wake up every day as TrainerRoad’s CEO, where I help thousands of athletes achieve their goals and become faster cyclists. I’ve been developing software since 2014, although my mobile development experience was extremely limited until 2013 when we started working with Xamarin to develop TrainerRoad’s iOS app. We couldn’t exist today, or continue to grow, without mobile: 50% of the platforms we support are mobile and nearly half of our customers use our Android or iOS apps.

Tell us about your app and how it fits into your mobile strategy.

TrainerRoad on an Android phoneTwo things make us the industry’s most effective training system: science and hard work. We bring the science, and our athletes bring the hard work; both are equally important to becoming a faster cyclist in the most efficient way possible. We combine technology with trusted, science-backed principles and deliver structured indoor workouts and plans to athletes across desktop, web, and mobile.

We’re always evaluating how we can provide the best training experience for our athletes, and mobile is a big part of the discussion. A lot of our athletes mount their cell phones to their handlebars to create an easier, more seamless training experience. We get that, and so mobile is—and always will be—a huge focus for us.

What sets your apps apart?

TrainerRoad is an all-in-one training system. When an athlete downloads our app they’re not just getting access to the best indoor cycling workouts; they get personalized training guidance just as they would if they had their own cycling or triathlon coach. We use our expertise to create structured training plans that tell riders exactly what to do to become as fast as possible, and they can track their progress throughout the training season via their personal performance dashboard.

What do you think about when you hear “native app”?

I think of the feel, launch time (it’s gotta be fast!), and how it looks. Without a doubt, Xamarin allows us to accomplish the native look and feel in a fraction of the time. Unlike most “shortcuts,” we’ve never had to compromise on quality using Xamarin. In fact, the quality of our apps has been better, because we execute new features and resolve bugs across all platforms much more quickly.

Why did you choose Xamarin?

TrainerRoad is unique because we share one codebase across four platforms (Windows, Mac, iOS and Android). All the guts of what we do—interacting with client devices, execution of workouts, syncing workouts, etc.—comes from this shared codebase. For our athletes to have a five-star experience, our apps must run seamlessly for the entire workout duration (one to two hours at a time), connect to external Bluetooth devices, connect to ANT (the fitness version of Bluetooth Smart), and instantly perform client-server interactions.

We’re a C# shop, and we specifically chose Xamarin. We knew our apps had to feel native, but we also wanted to build and implement new features across all our platforms quickly and simultaneously, which we’re able to do with Xamarin. We’ve recently switched to Xamarin.Forms to share even more code across Android and iOS.

There are very, very few companies that (1) are available on four platforms and (2) have the same thorny functional requirements we have. Managing our codebase’s complexity in the same programming language has been a game changer for our development team.

It’s a lot to handle, but Xamarin makes it all possible, allowing us to reuse our code across all platforms. Xamarin is a killer solution for us; we’ve saved so much time!

TrainerRoad on an iPhone

How long did it take to ship your app, from design to deploy?

We started with iOS, which took about a year, and our Android version took nine months. Without Xamarin, it would have taken us twice as long to build each app; we share nearly 90% of our code across platforms, which is huge for time savings.

How, and why, are you using Microsoft Azure?

All of our development servers are on Azure. We look for reliability and scale in a web hosting service, and Microsoft Azure delivers on both. Like many other software companies, we looked at AWS, but the integration with our existing technology appealed to us, and now I’d hate to not be on Azure. It’s saved us so much time and money.

Describe your development process and approach to mobile DevOps.

Our designers use InVision to create mock-ups for stakeholder sign-off and, once approved, we put them inside of Zeplin. From there, our weekly sprint planning meetings and GitHub projects define clear objectives and tasks for the dev team.

When an engineer picks up an issue and has a pull request ready, another engineer reviews the code before it goes to our testing team. After testing is complete, validated code goes into our development branch, and we publish nightly alpha and test builds to TestFlight and GooglePlay.

Why is mobile quality important?

You know what it’s like to get ready for a workout—there’s a lot of mental and physical preparation. Now imagine this: you’ve gotten yourself in the mindset to do your workout, eaten your pre-workout nutrition, changed into your gear, jumped onto your training equipment and… it doesn’t perform. That’s a fists-raised-in-the-air moment—like getting ready for a date only to be stood up. It leaves a bad taste in your mouth.

We try extremely hard to avoid our athletes ever experiencing that feeling. Testing, a lot of testing, is imperative to our app quality and our reputation. We have unit tests, integration tests, automated testing with Xamarin Test Cloud, and a test team. It’s extensive: team members physically get on bikes to ensure everything works seamlessly. For example, our automated testing suite once caught a mistake in our codebase that prevented users from signing in before we released it.

We treat testing like a first-class citizen in our development process. Without it, we’d risk a buggy app that riders wouldn’t recommend to their peers. We’re proud of our 76 NPS (Net Promoter Score), and it would sting for that to drop. So yes, we like to test, and in a variety of different ways!

It’s not feasible for us to have every device variation, and Xamarin Test Cloud gives us a breadth of devices. We have about 40 different variations of Android and iOS phones in-house, but of course that’s just the tip of the iceberg (if you look at just Android, there are over 24K device variations!).

Xamarin Test Cloud helps us run full regression tests, so we can ship beta builds to our internal teams and production releases to our customers as soon as possible.

What have your users said about your app?

TrainerRoad is an app built for cyclists by cyclists. Team members from across our development, test, support, and marketing teams are cyclists or have cycling experience. They use TrainerRoad for their own training, and we rely on them for internal testing and early product feedback. Our internal riders download our alpha and beta builds and share their commentary, ideas, and feature requests in our #rider-feedback Slack channel. We invite all teams to join our weekly product show-and-tells to make sure everyone, not just the development team, gives feedback on our in-development features.

The feedback we’ve received from TrainerRoad athletes who aren’t on our team is also incredible. We get a lot of amazing public reviews, but some of our most memorable feedback has been through our social and customer support channels. Last week, one of our athletes began a support chat, sharing that he’d been diagnosed and treated for cancer last year and how the treatments were grueling. He went on to tell us how our training system is exactly what he needed, and he’s started building his strength back up. It’s this kind of feedback that makes the whole team pause, reflect, and feel even more proud of what we’re accomplishing everyday.

What’s your team planning to build next?

We’re working to give riders a more complete, holistic view of their training, including features that automatically sync outdoor ride metrics into TrainerRoad.

What advice do you have for developers who are just starting out or investigating mobile development?

We recommend Xamarin’s educational tools; Xamarin University is a great resource. What we learned from Xamarin University courses got our team up to speed and going on mobile.
 
 
Visit xamarin.com/customers to learn how our customers across industries and geographies deliver amazing mobile apps, and visit xamarin.com/download to start building your own.

The post TrainerRoad Helps Cyclists Increase Performance with Five-Star Apps appeared first on Xamarin Blog.

May 24

Using Local Notifications in Xamarin.Mac

At Xamarin, we strive to empower you to create beautiful, practical, native mobile apps, but we also have a love of desktop applications. Xamarin.Mac and, more recently, Xamarin.Forms for Mac, give you everything you need to produce the same high quality app for the macOS desktop as you can for mobile devices.

Like mobile apps, a desktop app may not always be at the forefront of the user’s display. Sometimes we want to alert a user of something that’s happening, and local notifications are a great way to keep users engaged. Setting up local notifications with Xamarin.Mac takes just a few lines of code and is very similar to Xamarin.iOS. Today, we’re going to take another look at native Xamarin.Mac and add local notifications to our Pomodoro project, an app designed to help users segregate their workloads into 25 minute chunks.

Be sure to check out my Building Your First macOS App and Displaying Data with macOS Table Views blog posts if you haven’t already. You can also download today’s starting point here.

A Background On Notifications

The purpose of adding notifications to this app is to alert the user when 25 minutes has elapsed, even if the app is not in focus. As it stands, the dock icon bounces when the time has elapsed, since we’re displaying a modal alert; this is standard behavior on macOS and doesn’t require any extra coding from us. However, a bouncing dock icon does not provide any context as to what the alert is for (and can be quite annoying)!

Local notifications are different to push notifications in that you don’t need a web service such as Azure to push a notification to the app. The notification is set up in code locally and displayed when triggered manually in code. This is perfectly suited for our Pomodoro app, as we know exactly when we need to trigger the notification.

Adding the Code

The code for the notification is just a few lines. This needs to be added after we stop the timer; it doesn’t need be invoked on the main (UI) thread:

// Trigger a local notification after the time has elapsed
var notification = new NSUserNotification();
// Add text and sound to the notification
notification.Title = "25 Minutes is up!";
notification.InformativeText = "Add your task to your activity log";
notification.SoundName = NSUserNotification.NSUserNotificationDefaultSoundName;
notification.HasActionButton = true;
NSUserNotificationCenter.DefaultUserNotificationCenter.DeliverNotification(notification);

As you can see, we’re creating a notification in the code and then setting the title and text. We also have the opportunity to select a sound to be played. In this instance, we’ll just go with the default notification sound.

We’re also setting HasActionButton, which gives the notification two buttons by default: “close” and “show”. macOS also sets the app notifications to a “Banner” style notification by default, which doesn’t allow buttons. We can change this in System Preferences to an “Alert,” which will show buttons. There is, however, a way to force an Alert style notification by setting the following string value in Info.plist

<key>NSUserNotificationAlertStyle</key>
<string>alert</string>

Info.plist
Note: It’s important to note a quirk in macOS here. This setting will only affect the notification when the app is signed for release. During debugging this setting is ignored, so we need to set the alert type in System Preferences for now.

Trying it out

So, all we need to do now is test our new notification. Run the app, let the timer expire, and hopefully you’ll see the following notification:

Notofication

Having the notification as an alert improves the user experience, as the user can chooses to either close the notification or hit “show” to bring our app into focus.

Wrapping Up

Notifications are a powerful way to keep users interacting with your app, while also being able to display relevant information when needed. Setting up local notifications is simple and effective and doesn’t require any extra infrastructure. These notifications can also be extended in various ways by customizing the alert sound, buttons, and more advanced techniques such as providing a text field.

To view the completed project for this blog post, check out my Pomodoro GitHub repository here.

The post Using Local Notifications in Xamarin.Mac appeared first on Xamarin Blog.

May 23

Deep Dive into SkiaSharp with Xamarin.Forms

Xamarin.Forms is a versatile cross-platform user-interface toolkit that allows a single program to run on iOS, Android, the Universal Windows Platform, and (most recently) macOS.

However, one feature missing from Xamarin.Forms is a graphics system. Sure, Xamarin.Forms can render bitmaps, and you can size and rotate a BoxView for some simple blocky images, but for those of us who love graphics programming, Xamarin.Forms has a big polygon-shaped hole.

But don’t fret! A very compelling solution for Xamarin.Forms graphics is SkiaSharp, Xamarin’s C# library that incorporates Google’s powerful Skia Graphics Engine.Old-school graphics with SkiaSharp.

SkiaSharp is a cross-platform, high-performance 2D API for .NET developers perfect for mobile development. The API is straightforward to work with and can be used to do simple things, like drawing shapes or text, all the way to complex real-time drawing applications. The Xamarin team has even created a WYSIWYG graphics designer that puts out SkiaSharp graphics code.

As a member of Xamarin’s documentation team, I’ve been engaged in writing what I hope to be an extensive series of bite-sized tutorials on using SkiaSharp in Xamarin.Forms. These articles represent a deep dive into SkiaSharp, but one that I hope can also serve as an introduction to 2D graphics for newcomers. SkiaSharp shares many concepts with other 2D graphics drawing systems, so learning SkiaSharp is a terrific way to get a general education in 2D vector graphics.

Most recently, I’ve finished several articles on SkiaSharp Transforms. SkiaSharp supports all the basic graphics transforms found in other graphics systems, including translation, scaling, rotation, and skewing, which tilts graphics objects such as this shadow:

Example of drawing shadows in SkiaSharp.

That image uses an SKPaint object to define the characteristics of the text output. For the shadow (which is drawn first), the code sets a different color and a combination of translation, scaling, and skew to enlarge the text and tilt it to one side:

using (SKPaint textPaint = new SKPaint())
{
    textPaint.Style = SKPaintStyle.Fill;
    textPaint.TextSize = screenWidth / 6;
    textPaint.IsAntialias = true;
    // Common to shadow and text
    string text = "shadow";
    float xText = 20;
    float yText = screenHeight / 2;
    // Shadow
    textPaint.Color = SKColors.Gray;
    canvas.Save();
    canvas.Translate(xText, yText);
    canvas.Skew((float)Math.Tan(-Math.PI / 4), 0);
    canvas.Scale(1, 3);
    canvas.Translate(-xText, -yText);
    canvas.DrawText(text, xText, yText, textPaint);
    canvas.Restore();
    // Text
    textPaint.Color = SKColors.Blue;
    canvas.DrawText(text, xText, yText, textPaint);
}

SkiaSharp also supports standard matrix transforms, including non-affine transforms, which can achieve perspective and 3D rotation effects, such as the image at the top of this blog.

On mobile platforms and other modern devices, graphics is often intimately related to touch. Xamarin.Forms supports some rudimentary touch events, but not the essential tool of tracking individual fingers. More sophisticated touch tracking for Xamarin.Forms is now available with a Xamarin.Forms effect described in Invoking Events from Effects.

Combining SkiaSharp with touch tracking can result in some fun applications. I’ve recently created a Xamarin.Forms version of SpinPaint, based on a program I first wrote seven years ago for the Microsoft tabletop computer (originally called Surface and later renamed PixelSense).

SpinPaint simulates a rotating disk. Touch it or move your fingers on it, and it draws not only a line corresponding to your finger but three other lines that are mirror images, creating pretty patterns. Here’s SpinPaint running on iOS, Android, and the Universal Windows Platform:

Painting graphics with SkiaSharp

I think what impresses me most about SkiaSharp is its versatility. For example, other 2D graphics systems aren’t in total agreement about the best way to draw an arc, which is a curve on the circumference of an ellipse. Different graphics systems define the arc in very dissimilar ways.

SkiaSharp doesn’t force you into thinking of arcs in a particular way; rather, it supports three different ways to define an arc in a graphics path, so you can use the one that’s best for your particular application:

The angle arc requires that you specify a bounding rectangle for an ellipse, along with start angles and sweep angles:

path.AddArc(rect, startAngle, sweepAngle);

The resultant arc is shown here in red:

Angle arc drawn with SkiaSharp

This is identical to the AddArc and ArcTo methods of the Android Path object, and similar to the AddArc method of the iOS CGPath (although the iOS version is restricted to arcs on the circumference of a circle). This type of arc is great for pie charts.

The tangent arc is similar to the PostScript arct function and the iOS AddArcToPoint method. A radius of a circle is specified that is then fit snugly between two connected lines:

path.ArcTo(pointCorner, pointDestination, radius);

SkiaSharp draws a line and the arc, again shown in red:

Drawing a tangent arc with SkiaSharp.

The tangent arc is ideal for making rounded corners.

Finally, the elliptical arc allows you to specify two radii of an ellipse, as well as a rotation angle. The resultant tilted ellipse can fit between two points in two different ways, resulting in four different arcs between the two points, shown here in four different colors:

Drawing an elliptical arc with SkiaSharp.

You specify which of these four possible arcs you want with two further parameters:

ArcTo (radii, rotation, largeArcFlag, sweepDirectionFlag, point)

This type of arc specification is consistent with the elliptical arc supported by Scalable Vector Graphics (SVG) as well as the ArcSegment supported by XAML-based Windows graphics systems, including the Universal Windows Platform.

If you think arc-drawing is versatile, wait until you see SkiaSharp’s shaders and path effects! The shaders let you specify various gradients for filling in areas, including a linear gradient, radial gradient, conical gradient, sweep gradient, and random patterns called Perlin noise. The path effect can render a dotted or dashed line with any pattern of dots or dashes you want, but also render a line composed of little patterns:

SkiaSharp drawing a patterned texture.

Wrapping Up

There are still more SkiaSharp articles to come, so check the Using SkiaSharp in Xamarin.Forms page often to see what’s new.

Meanwhile, you’ll also want to register for Xamarin University Presents, a series of five must-see webinars in July, including one I’ll be doing on SkiaSharp Graphics for Xamarin.Forms.

The post Deep Dive into SkiaSharp with Xamarin.Forms appeared first on Xamarin Blog.

May 22

Staying Up-to-Date in Visual Studio 2017 with the Xamarin Updater

Traditionally, Xamarin developers have used our updater channels to stay up-to-date with frequent Xamarin releases, previews, and updates. To enable our developers to receive updates outside of the Visual Studio release cadence, we are introducing the Xamarin Updater extension for Visual Studio 2017, which allows you to receive updates to Xamarin for Visual Studio out-of-band, such as updates to the Xamarin Live Player or support for new versions of Xcode.

Installing the Xamarin Updater

Visual Studio 2017 provides two channels: Stable and Preview. The Xamarin Updater currently requires the Preview 15.3 release and will only provide preview updates on preview installations.

  1. Go to Tools -> Extensions & Updates.
  2. Navigate to Online -> Visual Studio Marketplace.
  3. Search for Xamarin Updater and press Download. The extension will be marked as “Created by: Xamarin”.
  4. Restart Visual Studio.

You now have the Xamarin Updater installed. This is will provide you preview updates on the preview channel of Visual Studio.

Keeping Up-to-Date with Xamarin

The Xamarin Updater will automatically push updates via the Extensions and Updates window. To receive updates (if available), go to the Updates tab, and press Update for each item to download all available updates.

Using the Xamarin Updater in Visual Studio 2017.

When the downloads have completed, a restart of Visual Studio is required to install the updates. After Visual Studio is closed, the updates downloaded above will be installed. You can follow along at releases.xamarin.com for release notes and information regarding updates shown in the Xamarin Updater and/or Visual Studio updater.

Wrapping Up

The Xamarin Updater extension for Visual Studio 2017 allows you to always be up-to-date with the latest Xamarin SDKs. This updater mechanism does not replace traditional updates to Visual Studio Stable and Preview, but instead is meant to supplement them. For more information, check out our documentation on changing the updater channel.

The post Staying Up-to-Date in Visual Studio 2017 with the Xamarin Updater appeared first on Xamarin Blog.

May 18

Glimpse the Future of Xamarin Forms 3.0

At Microsoft Build 2017 we shared our vision for Xamarin.Forms 3.0: to enable using Xamarin.Forms in more ways, on more platforms, and faster than ever before. Today, I want to walk you through some of the exciting new features that we’ll be adding to Xamarin.Forms that we know you’re going to love!

Xamarin.Forms Embedding

You’ve always been able to call native APIs from Xamarin.Forms, but now we’re allowing you to use Xamarin.Forms from a mostly native application.

Whether you’re going all-in on Xamarin.Forms, or just want to use it in your native applications where it benefits you most, we’re enabling all paths; we call this Xamarin.Forms Embedding. Take any ContentPage in XAML or C# and embed it directly into a Xamarin.iOS, Xamarin.Android, or UWP application.

All of your existing Xamarin.Forms UI now has extended use outside of Xamarin.Forms applications.
 
Here’s how it looks. In your non-Xamarin.Forms application it’s as simple as initializing Forms with the expected parameters for that platform and creating the native counterpart for the ContentPage using a convenient method. Just like that, you have native controls at your fingertips!

// Android
Forms.Init(this, null);
var androidFragment = new MyFormsPage().CreateFragment(this);
// iOS
Forms.Init()
var iosViewController = new MyFormsPage().CreateViewController();
// UWP
Forms.Init(e);
var uwpElement = new MyFormsPage().CreateFrameworkElement();

 

Xamarin.Forms features, such as DependencyService, MessagingCenter, and the data binding system, all still work in this scenario.

Reach More Platforms

Xamarin.Forms is heading to more platforms! Get ready to run on macOS, Linux, and even more Windows applications using WPF. We’ve started with macOS in preview today, but we aren’t stopping there—we’re enabling you to target every desktop platform! Our team is well under way developing for GTK# and WPF.

Speed Boosts and Enhancements

We’ve put Xamarin.Forms under the microscope to identify key targets for making your apps load faster and run quicker, specifically:

  • Control Renderers: we continue our work on what we appropriately call Fast Renderers. These refactored renderers avoid creating many intermediate objects and achieve much better performance.
  • Layout Compression: when enabled, we optimize your layout at compile time to improve rendering speed and minimize memory usage.
  • Binding System: we’re introducing one-time binding mode.
  • Flexibility: the popular Web layout system is coming to Xamarin.Forms. We’re introducing a FlexLayout system for building adaptive layouts and implementing a Visual State Manager.
  • Styling: we’re polishing up a CSS-inspired styling implementation that’s requested often. You can continue to style your applications as you do today, and if you’re a fan of CSS styling, it will now be a powerful option for you.

Introducing XAML Standard

As announced at Microsoft Build 2017, we’re collaborating with the Windows division on XAML Standard, a way to share XAML as an asset. Xamarin.Forms will fully support XAML Standard and take you to every platform you need to be on.

Frameworks that support XAML Standard will be able to share common XAML based UI definitions. Our goal is for the first version, XAML Standard 1.0, to be available later this year.

Try it Today and Join the Conversation

Here’s where you can get started today on all of the great stuff we’re cooking for Xamarin.Forms 3.0.

Download Xamarin.Forms 3.0 Preview

We’ve posted a preview of Xamarin.Forms Embedding to a new feed and shared our demo code. To get it:

  • Add a new source to your NuGet Manager: https://www.myget.org/F/xamarinforms-dev/api/v3/index.json
  • Check Pre-Release
  • Select and install the package with the feature name “Embedding”. 3.0.0.100-embeddingpreview
  • Download the Weather demo application code on GitHub. https://github.com/davidortinau/build2017-new-in-xamarin-forms

When you’re ready, explore the full Xamarin.Forms Roadmap and join the XAML Standard conversation on GitHub.

 

Watch our full Microsoft Build 2017 Xamarin.Forms session at channel9.msdn.com/events/Build/2017/B8099.

The post Glimpse the Future of Xamarin Forms 3.0 appeared first on Xamarin Blog.

May 17

Sharpen Your Mobile Development Skills with New “Xamarin University Presents” Webinars

Xamarin University Shield LogoThousands of developers attended our Xamarin University Presents webinar series earlier this year, and we had a great time introducing developers to the breadth of apps they can build with Xamarin Tools for Visual Studio. Now, our team of mobile experts are hosting five brand NEW demo-packed sessions, covering all things mobile and beyond. From building your first cloud-connected game with SpriteKit to adding intelligent APIs with Machine Learning, join us to get the training, samples, and advice you need to ship amazing mobile apps using the IDE, language, and code you know and love.

Beginning June 1, we’ll air a new topic every Thursday. Each expert-led session is free and open to everyone; whether you’re just getting started or want to broaden up your skills, our mobile experts will be on hand to answer your questions live.

Sign up now and be sure to register for the entire series. We encourage you to sign up for all of the webinars even if you’re unable to attend a session, as we’ll email the recordings to all registrants when they become available.
 

Register

  • June 1, 9 am PDT | Introduction to Xamarin.Forms for Visual Studio 2017: Learn how to take your .NET skills mobile with Visual Studio 2017 and Xamarin.Forms. Jesse Dietrichson, a Xamarin University instructor, will show you how to use the latest Visual Studio features to maximize code re-usage and design, develop, and test fully native apps for Android, iOS, and Windows, faster than ever.
  • June 8, 9 am PDT | Building games for iOS, macOS, and tvOS with Visual Studio and Azure: Create multiplayer games for the latest Apple devices, from iPhone to tvOS, with René Ruppert, Xamarin University instructor. He’ll teach SpriteKit basics, integration with cloud back-end services, and show you best practices for sharing C# game logic, UI, and infrastructure code cross-platform.
  • June 15, 9 am PDT | SkiaSharp Graphics for Xamarin.Forms: Get serious about graphics with special guest and popular author, Charles Petzold. You’ll learn how to use SkiaSharp, powered by Google’s Skia graphics library, to extend your Xamarin.Forms apps with compelling 2D graphics.
  • June 22, 9 am PDT | Customizing Xamarin.Forms UI: Embed native Android and iOS controls into your Xamarin.Forms apps. Join Rob Gibbens, Xamarin University training manager, to see how to integrate native controls and adjust visual properties unique to each platform – while still sharing the majority of your code. You’ll get the step-by-step guidance you need to take full advantage of the latest OS-specific UI patterns and designs.
  • June 29, 9 am PDT | Introduction to Azure Machine Learning: Start integrating intelligence and predictive analytics into your apps. Jason DeBoever, Xamarin University instructor, will introduce Machine Learning fundamentals, get you started with Azure Machine Learning Studio, and demo how to easily build your first “smart” mobile app.

Sign up today, bring your questions, and get ready to learn—we’ll see you soon!

The post Sharpen Your Mobile Development Skills with New “Xamarin University Presents” Webinars appeared first on Xamarin Blog.

Monologue

Monologue is a window into the world, work, and lives of the community members and developers that make up the Mono Project, which is a free cross-platform development environment used primarily on Linux.

If you would rather follow Monologue using a newsreader, we provide the following feed:

RSS 2.0 Feed

Monologue is powered by Mono and the Monologue software.

Bloggers