Quantcast
Channel: Category Name
Viewing all 5971 articles
Browse latest View live

Azure Monitor: Route AAD Activity Logs using diagnostic settings

$
0
0

Today in partnership with the Azure Active Directory (AAD) team we are excited to announce the public preview of AAD Activity Logs using Azure Monitor diagnostic settings. Azure Monitor diagnostic settings enable you to stream log data from an Azure service to three destinations: an Azure storage account, an Event Hubs namespace, and/or a Log Analytics workspace. This allows you to easily route logs from any Azure service to a data archive, SIEM tool, or custom log processing tool. With today’s announcement, you will now be able to route your AAD audit and sign in logs to these same destinations, centralizing all of your Azure service logs in one pipeline.

Until now, all log data handled by Azure Monitor came from an Azure resource deployed within an Azure subscription. We often describe this type of data as “resource-level log data,” and it is configured using a resource diagnostic setting. AAD log data is the first type of log data from a tenant-level service made available through Azure Monitor. Tenant-level services aren’t deployed as resources within an Azure subscription, rather they function across an entire AAD tenant. To handle this new type of “tenant-level log data,” Azure Monitor has introduced a new type of diagnostic setting, a tenant diagnostic setting. For AAD logs, you can setup a tenant diagnostic setting by navigating to Audit Logs in the AAD area of the portal and clicking “Export Data Settings.”

image

This will pull up the familiar Azure Monitor diagnostic setting experience, where you can create, modify, or delete diagnostic settings.

image

image To learn more about the feature and get started, check out Alex Simons’s post on the Enterprise Mobility and Security blog. Please also be aware that during the public preview AAD activity logs cannot yet be routed to Log Analytics, but we are working to enable this by October 2018. For a full list of services that expose logs through Azure Monitor, visit our documentation.


Announcing public preview of Azure IoT Hub manual failover feature

$
0
0

Today, we are announcing the public preview offering for Manual failover. This feature is part of IoT Hub cloud service and allows customers to failover an IoT hub instance from its primary Azure region to its corresponding geo-paired region.

Failures are possible in any software system especially when it's a distributed system and it is important to plan for failures. The IoT Hub service implements redundancies at various layers of its implementation to safeguard its customers against transient failures and failures scoped within a datacenter. The service offers a high level of SLA using these redundancies. However, region wide failures or extended outages, although remote are still possible.

The IoT Hub service provides cross regional automatic disaster recovery as a default mitigation for such failures. The recovery time objective for this recovery process is 2 – 26 hours. IoT solutions which cannot afford to be down for so long, can now use the IoT Hub manual failover feature to failover their IoT hubs from one region to another in a self-serve manner. The recovery time objective for IoT Hub manual failover is 10 min – 2 hours.

More details about this feature can be found in the article that outlines the high availability and disaster recovery features of the IoT Hub service. Use the How-to guide for manual failover as a step-by-step guide to perform manual failover for your hub. You can also check out the Internet of Things Show on Channel 9 to learn more about this feature.

Azure cloud business value for retail and consumer goods explained

$
0
0

For brick and mortar retailers, the world has been overturned. Online retailers have been demolishing their market share and icons of commerce are struggling. But what helped online retailers can help the offline. The cloud can also be used by brick and mortar retailers. In fact, the brick and mortar experience, transformed with cloud technology, can be a real advantage in competition with online only.

Reasons for retailers and consumer brands to move to the cloud

Cloud technologies are enabling new capabilities and those new powers are disrupting the business models of traditional retailers and sellers of consumer goods. The cloud is at the heart of digital transformation.

  • It is changing the way technology is implemented and managed.
  • It offers the benefit of massive scale, increased business speed, and organizational agility.
  • It makes possible economic benefits related to variable expense, maintenance and deployment.
  • It enables seamless consumer experiences between offline and online.
  • It encourages differentiated experiences that wow customers.

Now you have the key to competing in today’s landscape. For these reasons, it is no longer a question of “if,” but “when” and “how” to move to the cloud for most brands.

179697361

Business value of the cloud

Born-in-the-cloud retailers are entering the marketplace by solving long-standing consumer challenges in new and innovative ways. Modern technology capabilities allow them to accelerate benefits to both the consumer and business objectives. These new experiences raise the bar on what’s possible. They elevate consumers’ expectations by delivering relevancy and convenience, often at a fraction of the ecosystem footprint of long-standing retailers.

Each organization’s journey to the cloud will be unique. There will be a variety of reasons and benefits that should be acknowledged. However, here are the four major categories for cloud business value: cost, agility, performance, and new sources of value.

Evolved cost structure and transparency

Innovation doesn’t stop because of an organization’s budgeting cycle. Your internal processes should not impact your speed and agility to deliver improved experiences to your consumers.  If it does, as a leader you should add those processes to your list of things to evolve.

The cloud enables and encourages a continuous planning approach. It allows you to reap the full benefits of the cloud despite the traditional annual budgeting cycles. The dominant conversation related to cost becomes the shift from CapEx to OpEx. This fundamentally changes how organizations budget and pay for technology. Since fixed costs associated with shared infrastructure are distributed, the cloud enables greater visibility into the true cost of individual applications. The shift to variable expense offers the organization the ability to begin executing more quickly. And the organization becomes more agile through a fail-fast approach, especially given the lower barrier to initiatives. This enables you to experiment and deliver new concepts to customers. And for some brands, the ability to continually test and learn before committing to significant investments is extremely valuable. Especially when determining the relevancy of the offer and viability of the concept.

Improved agility, speed and productivity

Developing and deploying via on-premises infrastructures (datacenters) can take weeks to months. The cloud provides greater agility and speed-to-consumer. Development teams can be more productive and can quickly develop services that reach global markets. Azure offers near-instant provisioning, allowing projects to move quickly without the need to over-provision resources. As an added bonus, infrastructure planning costs disappear.

The flexibility of the cloud enables organizations to deploy new approaches more effectively. It lets you deliver value to customers and productivity to the organization. Profits accrue with the adoption of agile software development methodologies, DevOps, CI/CD, and modern SOA and PaaS-based architectures.

Azure cloud, made to order

Azure is designed with the developer in mind. Applications can be built with the language of choice, including Node.js, Java, and .NET. Development tools are available for PC or MAC. Visual Studio and Visual Studio Code are premier environments with built-in features for Azure. For example, mobile app development is accelerated by integrating the development lifecycle with Visual Studio App Center. Features include automated builds, and testing for cross-platform, hybrid, and native apps on iOS and Android.

Most compliant

Azure’s infrastructure has been developed to support global demand. Azure is available in 54 global Azure regions, more than any cloud provider. Azure has 70+ compliance offerings—the largest portfolio in the industry. Azure meets a broad set of international and industry-specific compliance standards, such as General Data Protection Regulation (GDPR), as well as country-specific standards, including Australia IRAP, UK G-Cloud, and Singapore MTCS. See Compliance for Microsoft cloud services.

Security matters

Security is essential to you and your customers. Here is a short list of how Azure offers improvements in reliability and security over on-premises infrastructure.

  • The Azure Security Center spans on-premises and cloud workloads. From a single dashboard, you can monitor and manage all of your resources.
  • The Azure Advisor is a free service that gives you the best advice based on the most current data. Azure Active Directory helps you to manage user identities and create intelligence-driven access policies to secure your resources.
  • Site Recovery gives you some assurance that you can recover from a disaster.
  • Individual services have security features. For example, see the security features of Azure SQL Database.

Possibilities to wow customers

The cloud enables unlimited computing scale and storage while removing boundaries. This freedom is a distinct advantage over on-premises infrastructure. This opens a wealth of new opportunities. It frees your organization’s creatives. They can imagine, prototype, and deliver new experiences that wow customers, leading to new business model opportunities.

These cloud capabilities, plus the availability of data and digital networks, provide an opportunity for modern technologies such as artificial intelligence, IoT, machine learning, and AR/VR to thrive. These technologies enable you to innovate and experiment. This leads to competitive advantages, many of which are only available in the cloud, and that are cost-prohibitive if implemented on-premises.

This is where it gets exciting for retail and consumer goods brands who are focused on delivering new and/or improved digital experiences. The cloud opens possibilities as new data signals are captured and used to provide insights fuelled with artificial intelligence.

Recommended next steps

Now that we discussed the business value of the cloud, it’s time to explore the platform and tooling that makes up Microsoft’s Azure cloud.  With a strong cloud foundation, you can start exploring the various industry options.

I post regularly about new developments on social media.  If you would like to follow me you can find me on Linkedin and Twitter.

Responsibilities of a partner/system integrator in managing Azure Cosmos DB

$
0
0

Note that this post was co-authored by Arvind Rao and Sneha Gunda.

Many customers are using Azure Cosmos DB all around the world. This article lists the actions a partner can perform in different areas of Azure Cosmos DB such as security, performance management, and more.

Security

Data security is a shared responsibility between the customer, and the database provider. Depending on the database provider, the amount of responsibility a customer carries can vary. If the customer chooses a PaaS cloud database provider such as Azure Cosmos DB, the workload to manage security reduces considerably. However there are some areas where the partner can add value by implementing security best practices offered by Azure Cosmos DB to help customer prevent, detect, and respond to database breaches.

Role of a partner

  • The partner has an opportunity to play database administrator (DBAs) role and help manage databases, collections, users, and permissions.
  • The partner can facilitate primary key rotation process to keep the connection to Azure Cosmos DB accounts secure.
  • The partner can create/manage user resources and permissions of the databases by using the master key for the account.
  • The partner can help configure and troubleshoot the IP access control policy.
  • The partner can help review the diagnostic logs to find any security issues.

Monitoring

Monitoring is the next focused area after customer start using one or more Azure Cosmos DB databases. Azure Cosmos DB provides full suite of metrics to monitor throughput, storage, availability, latency, and consistency of the databases.

Role of a partner

  • The partner can help monitor health of a database by using performance metrics.
  • The partner can help setup appropriate alerts to report health anomalies.
  • The partner can help configure diagnostic logging.
  • The partner can help review the logs for security anomalies.
  • The partner can help review the indexes and queries to provide appropriate changes.

Performance management

Performance Management focuses on managing required throughput and storage distribution across partitions, customizing index policies of a collection, query analysis and client metric analysis, and more.

Role of a partner

  • The partner can help improve the performance of a database by researching the throttling issues and applying the right fix like re-partitioning or adjusting the index policies.
  • The partner can help debugging slow client response or long running queries with the help of metrics and diagnostic logging information.
  • The partner can help review the consistency model and suggest appropriate consistency level for the server side to get more throughput.
  • The partner can help review TTL configuration and suggest appropriate configuration to choose a right size for the container.
  • The partner can help analyze the local demand to expand the databases to other regions to provide low latency reads.
  • The partner can provide guidance on the real-time integration or notification for any changes to Azure Cosmos DB.

Back up, restore, and business continuity

Azure Cosmos DB provides automatic online backup and supports explicit as well as policy driven failovers that allow customer to control the end-to-end system behavior in the event of failures.

Role of a partner

  • Azure Cosmos DB takes snapshots of your data for every four hours at the partition level. At any given time, only the last two snapshots are retained. The partner can help maintain additional backup snapshots if needed.
  • The partner can help restore a database from an online backup.
  • The partner can help address data corruption issues.
  • The partner can help by configuring automatic failovers.
  • The partner can perform manual failovers if needed.

Azure.Source – Volume 42

$
0
0

Now in preview

Azure App Service now supports Java SE on Linux - Support for Java SE 8-based applications on Linux in Azure App Service is now available in public preview. Now you can build and deploy Java web apps on a highly scalable, self-patching web hosting service where bug fixes and security updates will be maintained by Microsoft. Additional performance features include scaling to support millions of users with multiple instances, applications, and regions in a dynamic scaling intelligent configuration.

Build richer applications with the new asynchronous Azure Storage SDK for Java - Azure Storage SDK v10 for Java is currently in Preview and supports Blob storage only. Azure Storage SDK v10 for Java adopts the next-generation Storage SDK design providing thread-safe types that were introduced earlier with the Storage Go SDK release. This new SDK is built to effectively move data without any buffering on the client, and provides interfaces close to the ones in the Storage REST APIs.

Also in preview

Now generally available

Security Center’s adaptive application controls are generally available - Adaptive application controls help you define the set of applications that are allowed to run on configured groups of virtual machines (VM), which helps you audit and block unwanted applications. By default, Security Center enables application control in Audit mode. After validating that the whitelist has not had any adverse effects on your workload, you can change the protection mode to Enforce mode. This feature is available in the standard pricing tier of Security Center.

News and updates

New recommendations in Azure Advisor - Azure Advisor is a free service that analyzes your Azure usage and provides recommendations on how you can optimize your Azure resources to reduce costs, boost performance, strengthen security, and improve reliability. Several new Azure Advisor recommendations to help you get the most out of your Azure subscriptions, such as when to use Reserved Instances to help you save over pay-as-you-go costs, when you have subscriptions missing Azure Service Health alerts, when you should consider upgrading to a support plan that includes technical support, recommendations to solve common configuration issues with Traffic Manager profiles, and more.

Screenshot of Azure Advisor recommendations in the Azure portal.

Build secure Oozie workflows in Azure HDInsight with Enterprise Security Package - You can now use Oozie in domain-joined Hadoop clusters. Oozie is a workflow and coordination scheduler for Hadoop to accelerate and ease their big data implementation. Integrated with the Hadoop stack, Oozie supports several types of Hadoop jobs, but was previously unsupported with domain-joined clusters.

Accelerated and Flexible Restore Points with SQL Data Warehouse - SQL Data Warehouse (SQL DW) is a fully-managed and secure analytics platform for the enterprise, optimized for running complex queries fast across petabytes of data. We just released accelerated and flexible restore points, which will help you to quickly restore a data warehouse offers customers data protection from accidental corruption, deletion, and disaster recovery. You can now restore across regions and servers using any restore point instead of selecting geo-redundant backups, which are taken every 24 hours.

Top feature requests added with Azure Blockchain Workbench 1.2.0 - The second update of Azure Blockchain Workbench, which released to public preview at Build in May, is now available. You can either deploy a new instance of Workbench through the Azure Portal or upgrade your existing deployment to 1.2.0 using an upgrade script. This release includes a number of improvements and bug fixes, some of which are in response to customer feedback and suggestions.

Additional news and updates

The Azure Podcast

    The Azure Podcast | Episode 239 - Kubernetes Developer Tooling - We talk to Azure Engineer Michelle Noorali about her passion with the Cloud Native Computing Foundation and the work she does to enable Developers to work easily with Kubernetes in Azure and any cloud.

    Azure Tips & Tricks

    Azure Tips and Tricks | Add logic to your Testing in Production sites with PowerShell

    Technical content and training

    Orchestrating production-grade workloads with Azure Kubernetes Service - Brian Redmond, Cloud Architect, Azure Global Black Belt Team digs into the top scenarios that Azure customers are building on Azure Kubernetes Service on the third anniversary of Kubernetes. Azure Kubernetes Service (AKS) manages your hosted Kubernetes environment, making it quick and easy to deploy and manage containerized applications without container orchestration expertise. It also eliminates the burden of ongoing operations and maintenance by provisioning, upgrading, and scaling resources on demand, without taking your applications offline.

    Workflow diagram showing lift and shift to containers

    Feeding IoT device telemetry data to Kafka-based applications - With the newly released support for Kafka streams in Event Hubs, it is now possible for Azure IoT Hub customers to easily feed their IoT device telemetry data into Kafka-based applications for further downstream processing or analysis. You can start using IoT Hub's native support for messaging, device and configuration management early, and defer the decision to migrate your telemetry processing applications to natively use Event Hubs at a later time. This post covers applicable customer scenarios and how to use Kafka-based applications with IoT Hub telemetry.

    The IoT Show | Kafka Integration with Azure IoT Hub - Whether you are a Kafka aficionado or you are simply curious about how Azure IoT Hub allows to easily consume IoT devices data from Kafka, this new episode of the IoT Show is for you!

    Free course on the Log Analytics query language (KQL) now available - Some of the most commonly asked questions we get in Azure Log Analytics and Application Insights are around the query language. These come both from beginners who need a hand getting started, and intermediate users who want to know what advanced capabilities are available to them. We teamed-up with Pluralsight to provide a free course on KQL. Register and get started today.

    Azure Friday

    Azure Friday | ACR Build: Automate Docker builds with OS and framework patching - Steve Lasker joins Lara Rubbelke to discuss ACR Build, a cloud-native container build solution enabling pre-check, git commit and base image update docker builds for OS and framework patching.

    Azure Friday | Azure Stream Analytics: Managing timelines and coding on IoT Edge - Jean-Sébastien Brunner joins Lara Rubbelke to discuss new features that enable you to implement the intelligent cloud, intelligent edge vision for streaming analytics: Stream Analytics running real-time analytics with custom code on IoT Edge. We also discuss substreams, which is a new time management feature for independently processing the timeline of each device (very useful for an IoT scenario), and the recently announced Session Window.

    Events

    Containerize Your Applications with Kubernetes on Azure - In this webinar on Tuesday, August 14th (10:00-11:00am Pacific), you’ll see an end-to-end Kubernetes development experience on Azure, showcasing an integrated development environment for building apps. This includes application scaffolding, inner-loop workflows, application-management frameworks, CI/CD pipelines, log aggregation, and monitoring and application metrics.

    Customers and partners

    Azure Marketplace new offers: June 16–30 - The Azure Marketplace is the premier destination for all your software needs – certified and optimized to run on Azure. Find, try, purchase, and provision applications & services from hundreds of leading software providers. In the second half of June we published 22 new offers, including virtual machine images, web applications, container solutions, and consulting services.

    Announcing availability of Azure Managed Application in AzureGov - Azure Managed Applications enable Managed Service Provider (MSP), Independent Software Vendor (ISV) partners, and enterprise IT teams to deliver fully managed turnkey cloud solutions that can be made available through the enterprise Service Catalog of a specific end-customer. Customers can quickly deploy managed applications in their own subscription and rely on the partner or central IT team for maintenance operations and support across the lifecycle.

    Marketplace news from Inspire 2018 - Key marketplace sessions and content from Microsoft Inspire is now available for on-demand viewing, including: Grow your business with AppSource and Azure Marketplace, Best practices for successful GTM in Azure Marketplace and AppSource, Grow your PaaS or SaaS business in Azure Marketplace or AppSource, and Optimize your Microsoft Marketplace listing to attract new customers.

    Avoid Big Data pitfalls with Azure HDInsight and these partner solutions - Big data and the analytical application lifecycle spans a number of steps. Including ingestion, prep, storage, processing, analyzing and visualization. All of these steps need to have enterprise requirements around governance, access control, monitoring, security and more. Stitching an application together which comprises everything is a complicated task, which is why we worked closely with a selected set of ISV’s to certify their solutions with Azure HDInsight and other analytical services so customers can deploy them with a single-click. Check out this post for an overview of each of these solutions.

    Internet of Things Show

    Internet of Things Show | First look at Maps in Azure IoT Central - Azure Maps is now fully integrated in Azure IoT Central applications offering plenty geo-location and geocoding features. Check out this cool demo by Miriam Berhane Russom, PM in the Azure IoT Central team.

    Internet of Things Show | Azure IoT Hub Manual Failover - Disasters can happen and you should always be ready for failures in any distributed systems. Cloud services are no exception and Roopesh Manda, PM in the Azure IoT team, tells us how the IoT Hub will ensure your IoT application resiliency and how you can use the new Manual Failover feature of the service to test catastrophic scenarios.

    Industries

    Insurance | IoT: the catalyst for better risk management in insurance - Insurance companies that embrace digital transformation and technologies that include the Internet of Things (IoT), Artificial Intelligence (AI), Machine Learning (ML), and Big Data will lead the industry. Learn more in this post about thought leader Matteo Carbone's book, All the Insurance Players Will Be Insurtech.

    Retail | How to move your e-commerce infrastructure to Azure - Moving an existing e-commerce solution to the cloud presents many benefits for an enterprise: it enables scalability, it offers customers 24/7 accessibility, and it becomes easier to integrate cloud services. But first, to move an e-commerce solution to the cloud is a significant task, with costs that must be understood by a decision maker. Migrating your e-commerce solution to Azure overview explains the scope of an Azure migration with the goal of informing you of the options. The first phase begins with IT Pros moving the components to the cloud. Once on Azure, he describes the steps the e-commerce team can take to increase ROI and take advantage of the cloud.

    Healthcare | Current use cases for machine learning in healthcare - Machine learning (ML) is causing quite the buzz at the moment, and it’s having a huge impact on healthcare. Payers, providers and pharmaceutical companies are all seeing applicability in their spaces and are taking advantage of ML today. This post provides a quick overview of key topics in ML, and how it is being used in healthcare.

    A Cloud Guru | Azure This Week

    A Cloud Guru | Azure This Week - 27 July 2018 - In this episode of Azure This Week, Lars looks at the public preview of Azure Service Fabric Mesh, Azure Security Center integration and the general availability of Azure File Sync. He also looks at Azure Cloud Shell which is now embedded inside Visual Studio Code.

    Experts tips on hardening security with Azure security

    $
    0
    0

    Note: This blog was authored by the Microsoft Threat Intelligence Center.

    Microsoft Azure provides a secure foundation for customers to host their infrastructure and applications. Microsoft’s secure foundation spans across physical, infrastructure, and operational security. Part of our operational security includes over 3,500 cybersecurity experts across different teams that are dedicated to security research and development. The Microsoft Threat Intelligence Center is just one of the security teams at Microsoft that encounters and mitigates against threats across the security landscape.

    On today’s episode of Microsoft Mechanics, you’ll see how the work of the Microsoft Threat Intelligence Center is helping to secure Azure and the global security landscape. This team works to identify issues such as peer to peer networking software, standard botnet and ransomware attacks, and adversary-based threats from hackers or nation state sponsored groups.

    The team also has a broad view across many geographies and a view of the services that run in Azure. With this insight, the team can see common attack patterns. These patterns can be at the network level, service level, app level, or OS level. As soon as an exploit is detected, the Microsoft Threat Intelligence Center works with other teams at Microsoft to build mitigations into our products and services. In addition, the team creates threat intelligence reports that provide detailed information on things like what the attack was, where it happened, the environment(s) that were impacted and steps you need to take to remediate the attack. 

    In addition to seeing how the Microsoft Threat Intelligence Center mitigates attacks targeting the Azure platform, you’ll learn how that intelligence is fed back into our services and how you can strengthen your organizational security using these tools. For example, you can use Azure Security Center to get a centralized, real-time monitoring view into the security state of your hybrid cloud resources, and quickly take action against issues. You can also use Security Center’s Just-in-Time VM Access to protect against threats such as brute force attacks by reducing access to virtual machine management ports to only when it is needed. Security Center’s Investigation Path will help you explore all the entities involved an attack, such as a SQL injection, and quickly remediate against the attack.

    We hope that you find today’s overview helpful. Please let us know your thoughts, and feel free to post your questions.

    Plan your next trip – Customize Bing itineraries to make them your own

    $
    0
    0

    Just as every person is unique, we know every trip is unique.  A one-size-fits-all solution to travel is a start, but a great trip is one that caters to your interests.

    Earlier this year we introduced itineraries on Bing Maps for popular travel destinations (only available for US and UK users at this time).  We are excited to announce that you can now customize these itineraries to make them your own.

    To try it out, go to Bing Maps on your desktop browser and search for itineraries in the destination of your choice or a specific itinerary, for example 4 day New York itinerary.  From there you can…

    • Add the attractions you want to visit
    • Remove or re-order attractions to optimize your day
    • Add or remove days to fit your schedule
    • Save your itinerary to My Places for future editing
    • Share your itinerary with friends and family
    • Take your itinerary on the go – view it on your mobile phone

    Pro tip: Use the same link we give you to share with friends and family as a convenient shortcut to your itinerary on your mobile device.

    4 day new york itinerary

    Edit itinerary - My Places

    Edit Itinerary

    These new itinerary capabilities are available today.  We'll be working hard over the coming months to expand our travel planning offering on Bing so your input is greatly appreciated.  If you have suggestions or feedback, share them using the Feedback link on the page.

    - The Bing Team

    A Certification for R Package Quality

    $
    0
    0

    Cii_badge-300x300There are more than 12,000 packages for R available on CRAN, and many others available on Github and elsewhere. But how can you be sure that a given R package follows best development practices for high-quality, secure software?

    Based on a recent survey of R users related to challenges in selecting R packages, the R Consortium now recommends a way for package authors to self-validate that their package follows best practices for development. The CII Best Practices Badge Program, developed by the Linux Foundation's Core Infrastructure Initiative, defines a set of criteria that open-source software projects should follow for quality and security. The criteria relate to open-source license standards, documentation, secure development and delivery practices, version control and bug reporting practices, build and test processes, and much more. R packages that meet these standards are a signal to R users that can be relied upon, and as the standards document notes:

    There is no set of practices that can guarantee that software will never have defects or vulnerabilities; even formal methods can fail if the specifications or assumptions are wrong. Nor is there any set of practices that can guarantee that a project will sustain a healthy and well-functioning development community. However, following best practices can help improve the results of projects. For example, some practices enable multi-person review before release, which can both help find otherwise hard-to-find technical vulnerabilities and help build trust and a desire for repeated interaction among developers from different organizations.

    Developers can self-validate their packages (free of charge) using an online tool to check their adherence to the standards and get a "passing", "silver" or "gold" rating. Passing projects are eligible to display the badge (shown above) as a sign of quality and security, and almost 200 projects qualify as of this writing. That includes a number of R packages that have already gone through the certification process, including ggplot2, R Consortium projects covr and DBI, and the built-in R package Matrix Matrix. For more details on how R packages can get to a passing certification, and the R Consortium survey they led to the recommendation, see the R Consortium blog post at the link below.

    R Consortium: Should R Consortium Recommend CII Best Practices Badge for R Packages: Latest Survey Results

     


    Announcing TypeScript 3.0

    $
    0
    0
    TypeScript 3.0 is here! Today marks a new milestone in the TypeScript journey, serving JavaScript users everywhere.

    If you’re unfamiliar with TypeScript, it’s not too late to learn about it now! TypeScript is an extension of JavaScript that aims to bring static types to modern JavaScript. The TypeScript compiler reads in TypeScript code, which has things like type declarations and type annotations, and emits clean readable JavaScript with those constructs transformed and removed. That code runs in any ECMAScript runtime like your favorite browsers and Node.js. At its core, this experience means analyzing your code to catch things like bugs and typos before your users run into them; but it brings more than that. Thanks to all that information and analysis TypeScript can provide a better authoring experience, providing code completion and navigation features like Find all References, Go to Definition, and Rename in your favorite editor.

    To get started with the language itself, check out typescriptlang.org to learn more. And if you want to try TypeScript 3.0 out now, you can get it through NuGet or via npm by running

    npm install -g typescript

    You can also get editor support for

    Other editors may have different update schedules, but should all have excellent TypeScript support soon as well.

    The 3.0 Journey

    When we released TypeScript 2.0, we took a brief look back at how each release leading up to TypeScript 2.0 brought the language to where it is today. Between TypeScript 1.0 and up until 2.0, the language added union types, type guards, modern ECMAScript support, type aliases, JSX support, literal types, and polymorphic this types. If we include TypeScript 2.0 with its introduction of non-nullable types, control flow analysis, tagged union support, this-types, and a simplified model around .d.ts file acquisition, that era truly defined the fundamentals of using TypeScript.

    So what have we done since? What, apart from new ECMAScript features like the long-await-ed async/await, generators, and object rest/spread brought us to TypeScript 3.0?

    TypeScript 2.1 was a foundational release that introduced a static model for metaprogramming in JavaScript. The key query (keyof), indexed access (T[K]), and mapped object ({ [K in keyof T]: T[K] }) types have been instrumental in better modeling libraries like React, Ember, Lodash, and more.

    TypeScript 2.2 and 2.3 brought support for mixin patterns, the non-primitive object type, and generic defaults, used by a number of projects like Angular Material and Polymer. TypeScript 2.3 also shipped a feature for fine-grained control of this types that allowed TypeScript to work well with libraries like Vue, and added the checkJs flag to enable type-checking on JavaScript files.

    TypeScript 2.4 and 2.6 tightened up the story for strict checking on function types, addressing some of the longest-standing feedback about our type system through --strictFunctionTypes which enforced contravariance on parameters. 2.7 continued the trend of strictness with --strictPropertyInitialization checks in classes.

    TypeScript 2.8 introduced conditional types, a powerful tool for statically expressing decisions based on types, and 2.9 generalized keyof and provided easier imports for types.

    Which brings us to TypeScript 3.0! Despite the new big number, 3.0 has few breaking changes (meaning it should be very easy to upgrade) and introduces a new flexible and scalable way to structure your projects, powerful new support for operating on parameter lists, new types to enforce explicit checks, better JSX support, an overall better error UX, and much more!

    What’s New?

    Project references

    It’s fairly common to have several different build steps for a library or application. Maybe your codebase has a src and a test directory. Maybe you have your front-end code in a folder called client with your Node.js back-end code in a folder called server, and each imports code from a shared folder. And maybe you use what’s called a “monorepo” and have many many projects which depend on each other in non-trivial ways.

    One of the biggest features that we’ve worked on for TypeScript 3.0 is called “project references”, and it aims to make working with these scenarios easier.

    Project references allow TypeScript projects to depend on other TypeScript projects – specifically, allowing tsconfig.json files to reference other tsconfig.json files. Specifying these dependencies makes it easier to split your code into smaller projects, since it gives TypeScript (and tools around it) a way to understand build ordering and output structure. That means things like faster builds that work incrementally, and support for transparently navigating, editing, and refactoring across projects. Since 3.0 lays the foundation and exposes the APIs, any build tool should be able to provide this.

    What’s it look like?

    As a quick example, here’s what a tsconfig.json with project references looks like:

    // ./src/bar/tsconfig.json
    {
        "compilerOptions": {
            // Needed for project references.
            "composite": true,
            "declaration": true,
    
            // Other options...
            "outDir": "../../lib/bar",
            "strict": true, "module": "esnext", "moduleResolution": "node",
        },
        "references": [
            { "path": "../foo" }
        ]
    }

    There are two new fields to notice here: composite and references.

    references simply specifies other tsconfig.json files (or folders immediately containing them). Each reference is currently just an object with a path field, and lets TypeScript know that building the current project requires building that referenced project first.

    Perhaps equally important is the composite field. The composite field ensures certain options are enabled so that this project can be referenced and built incrementally for any project that depends on it. Being able to intelligently and incrementally rebuild is important, since build speed is one of the reasons you might break up a project in the first place. For example, if project front-end depends on shared, and shared depends on core, our APIs around project references can be used to detect a change in core, but to only rebuild shared if the types (i.e. the .d.ts files) produced by core have changed. That means a change to core doesn’t completely force us to rebuild the world. For that reason, setting composite forces the declaration flag to be set as well.

    --build mode

    TypeScript 3.0 will provide a set of APIs for project references so that other tools can provide this fast incremental behavior. As an example, gulp-typescript already leverages it! So project references should be able to integrate with your choice of build orchestrators in the future.

    However, for many simple apps and libraries, it’s nice not to need external tools. That’s why tsc now ships with a new --build flag.

    tsc --build (or its nickname, tsc -b) takes a set of projects and builds them and their dependencies. When using this new build mode, the --build flag has to be set first, and can be paired with certain other flags:

    • --verbose: displays every step of what a build requires
    • --dry: performs a build without emitting files (this is useful with --verbose)
    • --clean: attempts to remove output files given the inputs
    • --force: forces a full non-incremental rebuild for a project

    Controlling output structure

    One subtle but incredibly useful benefit of project references is logically being able to map your input source to its outputs.

    If you’ve ever tried to share TypeScript code between the client and server of your application, you might have run into problems controlling the output structure.

    For example, if client/index.ts and server/index.ts both reference shared/index.ts for the following projects:

    src
    ├── client
    │   ├── index.ts
    │   └── tsconfig.json
    ├── server
    │   ├── index.ts
    │   └── tsconfig.json
    └── shared
        └── index.ts
    

    …then trying to build client and server, we’ll end up with…

    lib
    ├── client
    │   ├── client
    │   │   └── index.js
    │   └── shared
    │       └── index.js
    └── server
        ├── server
        │   └── index.js
        └── shared
            └── index.js
    

    rather than

    lib
    ├── client
    │   └── index.js
    ├── shared
    │   └── index.js
    └── server
        └── index.js
    

    Notice that we ended up with a copy of shared in both client and server. We unnecessarily spent time building shared twice and introduced an undesirable level of nesting in lib/client/client and lib/server/server.

    The problem is that TypeScript greedily looks for .ts files and tries to include them in a given compilation. Ideally, TypeScript would understand that these files don’t need to be built in the same compilation, and would instead jump to the .d.ts files for type information.

    Creating a tsconfig.json for shared and using project references does exactly that. It signals to TypeScript that

    1. shared should be built independently, and that
    2. when importing from ../shared, we should look for the .d.ts files in its output directory.

    This avoids triggering a double-build, and also avoids accidentally absorbing all the contents of shared.

    Further work

    To get a deeper understanding of project references and how you can use them, read up more our issue tracker. In the near future, we’ll have documentation on project references and build mode.

    We’re committed to ensuring that other tool authors can support project references, and will continue to improve the editing experience around project references. Our intent is for project references to feel as seamless as authoring code with a single tsconfig.json. If you do end up using project references, we’d appreciate any and all feedback to do just that.

    Extracting and spreading parameter lists with tuples

    We often take it for granted, but JavaScript lets us think about parameter lists as first-class values – either by using arguments or rest-parameters (e.g. ...rest).

    function call(fn, ...args) {
        return fn(...args);
    }

    Notice here that call works on functions of any parameter length. Unlike other languages, JavaScript doesn’t force us to define a call0, call1, call2, etc. as follows:

    function call0(fn) {
        return fn();
    }
    
    function call1(fn, param1) {
        return fn(param1);
    }
    
    function call2(fn, param1, param2) {
        return fn(param1, param2);
    }
    
    function call3(fn, param1, param2, param3) {
        return fn(param1, param2, param3);
    }

    Unfortunately, for a while there wasn’t a great well-typed way to express this statically in TypeScript without declaring a finite number of overloads:

    // TODO (billg): 5 overloads should *probably* be enough for anybody?
    function call<T1, T2, T3, T4, R>(fn: (param1: T1, param2: T2, param3: T3, param4: T4) => R, param1: T1, param2: T2, param3: T3, param4: T4): R
    function call<T1, T2, T3, R>(fn: (param1: T1, param2: T2, param3: T3) => R, param1: T1, param2: T2, param3: T3): R
    function call<T1, T2, R>(fn: (param1: T1, param2: T2) => R, param1: T1, param2: T2): R
    function call<T1, R>(fn: (param1: T1) => R, param1: T1): R;
    function call<R>(fn: () => R, param1: T1): R;
    function call(fn: (...args: any[]) => any, ...args: any[]) {
        return fn(...args);
    }

    Oof! Another case of death by a thousand overloads! Or at least, as many overloads as our users asked us for.

    TypeScript 3.0 allows us to better model scenarios like these by now allowing rest parameters to be generic, and inferring those generics as tuple types! Instead of declaring each of these overloads, we can say that the ...args rest parameter from fn must be a type parameter that extends an array, and then we can re-use that for the ...args that call passes:

    function call<TS extends any[], R>(fn: (...args: TS) => R, ...args: TS): R {
        return fn(...args);
    }

    When we call the call function, TypeScript will try to extract the parameter list from whatever we pass to fn, and turn that into a tuple:

    function foo(x: number, y: string): string {
        return (x + y).toLowerCase();
    }
    
    // The `TS` type parameter is inferred as `[number, string]`
    call(foo, 100, "hello");

    When TypeScript infers TS as [number, string] and we end up re-using TS on the rest parameter of call, the instantiation looks like the following

    function call(fn: (...args: [number, string]) => string, ...args: [number, string]): string

    And with TypeScript 3.0, using a tuple in a rest parameter gets flattened into the rest of the parameter list! The above boils down to simple parameters with no tuples:

    function call(fn: (arg1: number, arg2: string) => string, arg1: number, arg2: string): string

    So in addition to catching type errors when we pass in the wrong arguments:

    function call<TS extends any[], R>(fn: (...args: TS) => R, ...args: TS): R {
        return fn(...args);
    }
    
    call((x: number, y: string) => y, "hello", "world");
    //                                ~~~~~~~
    // Error! `string` isn't assignable to `number`!

    and inference from other arguments:

    call((x, y) => { /* .... */ }, "hello", 100);
    //    ^  ^
    // `x` and `y` have their types inferred as `string` and `number` respectively.

    we can also observe the tuple types that these functions infer from the outside:

    function tuple<TS extends any[]>(...xs: TS): TS {
        return xs;
    }
    
    let x = tuple(1, 2, "hello"); // has type `[number, number, string]

    There is a subtler point to note though. In order to make all of this work, we needed to expand what tuples could do…

    Richer tuple types

    To make tuples model parameter lists (as we just discussed), we had to rethink tuple types a bit. Before TypeScript 3.0, the best that tuples could model was the order and count of a set of parameters.

    However, parameter lists aren’t just ordered lists of types. For example, parameters at the end can be optional:

    // Both `y` and `z` are optional here.
    function foo(x: boolean, y = 100, z?: string) {
        // ...
    }
    
    foo(true);
    foo(true, undefined, "hello");
    foo(true, 200);

    The last parameter can be a rest parameter.

    // `rest` accepts any number of strings - even none!
    function foo(...rest: string[]) {
        // ...
    }
    
    foo();
    foo("hello");
    foo("hello", "world");

    And finally, there is one mildly interesting property about parameter lists which is that they can be empty:

    // Accepts no parameters.
    function foo() {
        // ...
    }
    
    foo();

    So to make it possible for tuples to correspond to parameter lists, we needed to model each of these scenarios.

    First, tuples now allow trailing optional elements:

    /**
     * 2D, or potentially 3D, coordinate.
     */
    type Coordinate = [number, number, number?];

    The Coordinate type creates a tuple with an optional property named 2 – the element at index 2 might not be defined! Interestingly, since tuples use numeric literal types for their length properties, Coordinate‘s length property has the type 2 | 3.

    Second, tuples now allow rest elements at the end.

    type OneNumberAndSomeStrings = [number, ...string[]];

    Rest elements introduce some interesting open-ended behavior to tuples. The above OneNumberAndSomeStrings type requires its first property to be a number, and permits 0 or more strings. Indexing with an arbitrary number will return a string | number since the index won’t be known. Likewise, since the tuple length won’t be known, the length property is just number.

    Of note, when no other elements are present, a rest element in a tuple is identical to itself:

    type Foo = [...number[]]; // Equivalent to `number[]`.

    Finally, tuples can now be empty! While it’s not that useful outside of parameter lists, the empty tuple type can be referenced as []:

    type EmptyTuple = [];

    As you might expect, the empty tuple has a length of 0 and indexing with a number returns the never type.

    Improved errors and UX

    Over time we’ve heard more and more demand from our community regarding better error messages. While we’re by no means done, we heard you in TypeScript 3.0 and have invested a bit here.

    Related error spans

    Part of the goal of providing a good error message is also guiding a user towards a way to fix the error, or providing a way to intuit why the error message was given in the first place. Much of the time, there can be a lot of information or multiple reasons an error message might surface. Of those reasons, we might find they come from different parts of the code.

    Related error spans are a new way to surface that information to users. In TypeScript 3.0, error messages can provide messages on other locations so that users can reason about cause-and-effect of an error.

    Using import * as express syntax can cause an error when calling express(). Here, the provided error tells the user not just that the call is invalid, but that it has occurred because of the way the user imported express.

    In some sense, related error messages can give a user not just an explanation, but also breadcrumbs to see where things went wrong.

    An error on a potentially misspelled property now also informs the user of where the most likely candidate originated.

    These spans will also appear in the terminal when running tsc with --pretty mode enabled, though our team is still iterating on the UI and would appreciate feedback!

    Improved messages and elaboration

    Around TypeScript 2.9, we started investing more in our error messages, and with 3.0 we really tried to tackle a core set of cases that could give a smarter, cleaner, and more accurate error experience. This includes things like picking better types with mismatches in union types, and cutting right to the chase for certain error messages.

    We believe this effort had paid off and will provide significantly shorter and cleaner error messages.

    Error messages for the equivalent code/issue in JSX compared between TypeScript 2.8 and TypeScript 3.0. In TypeScript 3.0, the message is dramatically shorter and has a related span, while still providing context.

    The unknown type

    The any type is the most-capable type in TypeScript – while it encompasses the type of every possible value, it doesn’t force us to do any checking before we try to call, construct, or access properties on these values. It also lets us assign values of type any to values that expect any other type.

    This is mostly useful, but it can be a bit lax.

    let foo: any = 10;
    
    // All of these will throw errors, but TypeScript
    // won't complain since `foo` has the type `any`.
    foo.x.prop;
    foo.y.prop;
    foo.z.prop;
    foo();
    new foo();
    upperCase(foo);
    foo `hello world!`;
    
    function upperCase(x: string) {
        return x.toUpperCase();
    }

    There are often times where we want to describe the least-capable type in TypeScript. This is useful for APIs that want to signal “this can be any value, so you must perform some type of checking before you use it”. This forces users to safely introspect returned values.

    TypeScript 3.0 introduces a new type called unknown that does exactly that. Much like any, any value is assignable to unknown; however, unlike any, unknown is assignable to almost nothing else without a type assertion. You also can’t access any properties off of an unknown, nor can you call/construct them.

    As an example, swapping the above example to use unknown instead of any forces turns all usages of foo into an error:

    let foo: unknown = 10;
    
    // Since `foo` has type `unknown`, TypeScript
    // errors on each of these locations.
    foo.x.prop;
    foo.y.prop;
    foo.z.prop;
    foo();
    new foo();
    upperCase(foo);
    foo `hello world!`;
    
    function upperCase(x: string) {
        return x.toUpperCase();
    }

    Instead, we’re now forced to either perform checking, or use a type assertion to convince the type-system that we know better.

    let foo: unknown = 10;
    
    function hasXYZ(obj: any): obj is { x: any, y: any, z: any } {
        return !!obj &&
            typeof obj === "object" &&
            "x" in obj && "y" in obj && "z" in obj
    }
    
    // Using a user-defined type guard...
    if (hasXYZ(foo)) {
        // ...we're allowed to access certain properties again.
        foo.x.prop;
        foo.y.prop;
        foo.z.prop;
    }
    
    // We can also just convince TypeScript we know what we're doing
    // by using a type assertion.
    upperCase(foo as string);
    
    function upperCase(x: string) {
        return x.toUpperCase();
    }

    Note that if you’ve been using a type like {} | null | undefined to achieve similar behavior, unknown usually has more desirable behavior in constructs like conditional types, since conditional types distribute across unions:

    type Arrayify<T> = T extends any ? Array<T> : never;
    
    type A = Foo<{} | null | undefined>; // null[] | undefined[] | {}[]
    type B = Foo<unknown>;               // unknown[]

    Support for defaultProps in JSX

    Note: at the time of writing, React’s .d.ts files may not yet support this functionality.

    If you’ve ever used default initializers in modern TypeScript/JavaScript, you might know how handy they can be for function callers. They give us a useful syntax to let callers use functions more easily by not requiring certain arguments, while letting function authors ensure that their values are always defined in a clean way.

    function loudlyGreet(name = "world") {
        // Thanks to the default initializer, `name` will always have type `string` internally.
        // We don't have to check for `undefined` here.
        console.log("HELLO", name.toUpperCase());
    }
    
    // Externally, `name` is optional, and we can potentially pass `undefined` or omit it entirely.
    loudlyGreet();
    loudlyGreet(undefined);

    In React, a similar concept exists for components and their props. When creating a new element using a component, React looks up a property called defaultProps, to fill in values for props that are omitted.

    // Some non-TypeScript JSX file
    
    import * as React from "react";
    import * as ReactDOM from "react-dom";
    
    export class Greet extends React.Component {
        render() {
            const { name } = this.props;
            return <div>Hello ${name.toUpperCase()}!</div>;
        }
    
        static defaultProps = {
            name: "world",
        };
    }
    
    //      Notice no `name` attribute was specified!
    //                                     vvvvvvvvv
    const result = ReactDOM.renderToString(<Greet />);
    console.log(result);

    Notice that in <Greet />, name didn’t have to be specified. When a Greet element is created, name will be initialized with "world" and this code will print <div>Hello world!</div>.

    Unfortunately, TypeScript didn’t understand that defaultProps had any bearing on JSX invocations. Instead, users would often have to declare properties optional and use non-null assertions inside of render:

    export interface Props { name?: string }
    export class Greet extends React.$1Component<Props> {
        render() {
            const { name } = this.props;
    
            // Notice the `!` ------v
            return <div>Hello ${name!.toUpperCase()}!</div>;
        }
        static defaultProps = { name: "world"}
    }

    Or they’d use some hacky type-assertions to fix up the type of the component before exporting it.

    That’s why TypeScript 3.0, the language supports a new type alias in the JSX namespace called LibraryManagedAttributes. Despite the long name, this is just a helper type that tells TypeScript what attributes a JSX tag accepts. The short story is that using this general type, we can model React’s specific behavior for things like defaultProps and, to some extent, propTypes.

    export interface Props {
        name: string
    }
    
    export class Greet extends React.$1Component<Props> {
        render() {
            const { name } = this.props;
            return <div>Hello ${name.toUpperCase()}!</div>;
        }
        static defaultProps = { name: "world"}
    }
    
    // Type-checks! No type assertions needed!
    let el = <Greet />

    Keep in mind that there are some limitations. For defaultProps that explicitly specify their type as something like Partial<Props>, or stateless function components (SFCs) whose defaultProps are declared with Partial<Props>, will make all props optional. As a workaround, you can omit the type annotation entirely for defaultProps on a class component (like we did above), or use ES2015 default initializers for SFCs:

    function Greet({ name = "world" }: Props) {
        return <div>Hello ${name.toUpperCase()}!</div>;
    }

    One last thing to note is that while the support is built into TypeScript, the current .d.ts files on DefinitelyTyped are not currently leveraging it – therefore @types/react may not have the change available yet. We are currently waiting on stabilization throughout DefinitelyTyped to ensure that the change is minimally disruptive.

    /// <reference lib="..." /> directives

    One of the issues we’ve seen in the community is that polyfills – libraries that provide newer APIs in older runtimes – often have their own declaration files (.d.ts files) that attempt to define those APIs themselves. While this is sometimes fine, these declarations are global, and may provide issues with TypeScript’s built-in lib.d.ts depending on users’ compiler options like --lib and --target. For example, declarations for core-js might conflict with the built-in lib.es2015.d.ts.

    To solve this, TypeScript 3.0 provides a new way for files to declare the built-in APIs which they expect to be present using a new reference directive: /// <reference lib="..." />.

    For example, a polyfill for ES2015’s Promise might now simply contain the lines

    /// <reference lib="es2015.promise" />
    export {};

    With this comment, even if a TypeScript 3.0 consumer has explicitly used a target that doesn’t bring in lib.es2015.promise.d.ts, importing the above library will ensure that Promise is present.

    Editor Productivity

    For those who are unfamiliar, TypeScript leverages its syntactic and semantic knowledge to provide services for writing code more easily. It acts as the engine for TypeScript and JavaScript underneath editors like Visual Studio, Visual Studio Code, and any other editor with a TypeScript plugin to provide the things users love like code completion, Go to Definition, and even quick fixes and refactorings. TypeScript 3.0 continues to deliver here.

    Named import refactorings

    Occasionally, qualifying every import with the module it came from can be cumbersome.

    import * as dependency from "./dependency";
    
    // look at all this repetition!
    
    dependency.foo();
    
    dependency.bar();
    
    dependency.baz();

    On the other hand, if we individually import the things we use, we might find that after many uses it’s become unclear for new readers where these imports originated from.

    import { foo, bar, baz } from "./dependency";
    
    // way lower in the file...
    
    foo();
    
    bar();
    
    baz();

    Regardless of which you decide to choose now, you might change your mind later. TypeScript 3.0 provides refactorings so that switch never feels daunting.

    Closing JSX tag completions and outlining spans

    TypeScript now provides two new productivity features around JSX:

    • providing completions for JSX closing tags
    • providing collapsible outlining spans for JSX

    Quick fixes for unreachable code and unused labels

    TypeScript will now provide quick fixes to remove any unreachable code, as well as remove unused labels.

    Breaking changes

    You can always keep an eye on upcoming breaking changes in the language as well as in our API.

    We expect TypeScript 3.0 to have very few impactful breaking changes. Language changes should be minimally disruptive, and most breaks in our APIs are oriented around removing already-deprecated functions.

    unknown is a reserved type name

    Since unknown is a new built-in type, it can no longer be used in type declarations like interfaces, type aliases, or classes.

    API breaking changes

    • The deprecated internal method LanguageService#getSourceFile has been removed, as it has been deprecated for two years. See #24540.
    • The deprecated function TypeChecker#getSymbolDisplayBuilder and associated interfaces have been removed. See #25331. The emitter and node builder should be used instead.
    • The deprecated functions escapeIdentifier and unescapeIdentifier have been removed. Due to changing how the identifier name API worked in general, they have been identity functions for a few releases, so if you need your code to behave the same way, simply removing the calls should be sufficient. Alternatively, the typesafe escapeLeadingUnderscores and unescapeLeadingUnderscores should be used if the types indicate they are required (as they are used to convert to or from branded __String and string types).
    • The TypeChecker#getSuggestionForNonexistentProperty, TypeChecker#getSuggestionForNonexistentSymbol, and TypeChecker#getSuggestionForNonexistentModule methods have been made internal, and are no longer part of our public API. See #25520.

    Going forward

    TypeScript owes so much of its success to its community. We’re indebted to our contributors who’ve worked on the compiler, the language service, DefinitelyTyped, and tooling integration that leveraged any combination of them. But we’re also grateful for our users who’ve consistently given us the feedback we needed and pushed us to improve. Going forward, we foresee bringing more value to the type system and tooling experience, polishing the existing work on project references, and making TypeScript (both the language and the project) more approachable by whatever means we can. But in addition to that, we want to explore what we can do to empower more tool authors and users in the JavaScript community – to bring value to users who could still get value from using TypeScript even without directly using TypeScript.

    Keep an eye on our roadmap as these ideas become specifics, and feel free to drop us a line to give us feedback, whether via the comments below, over Twitter, or by filing an issue. We’re always trying to do better.

    For everyone who’s been a part of the TypeScript journey so far – thank you. We look forward to bringing you the best experience we can. And for everyone else, we hope you’ll start exploring and loving TypeScript as much as we do.

    Happy hacking!

    The TypeScript Team

    Introducing Web Authentication in Microsoft Edge

    $
    0
    0

    Today, we are happy to introduce support for the Web Authentication specification in Microsoft Edge, enabling better, more secure user experiences and a passwordless experience on the web.

    With Web Authentication, Microsoft Edge users can sign in with their face, fingerprint, PIN, or portable FIDO2 devices, leveraging strong public-key credentials instead of passwords.

    A web without passwords

    Staying secure on the web is more important than ever. We trust web sites to process credit card numbers, save addresses and personal information, and even to handle sensitive records like medical information. All this data is protected by an ancient security model—the password. But passwords are difficult to remember, and are fundamentally insecure—often re-used, and vulnerable to phishing and cracking.

    For these reasons, Microsoft has been leading the charge towards a world without passwords, with innovations like Windows Hello biometrics and pioneering work with the FIDO Alliance to create an open standard for passwordless authentication – Web Authentication.

    We started this journey in 2016, when we shipped the industry’s first preview implementation of the Web Authentication API in Microsoft Edge. Since then, we have been updating our implementation to as we worked with other vendors and the FIDO alliance to develop the standard. In March, the FIDO Alliance announced that the Web Authentication APIs have reached Candidate Recommendation (CR) status in the W3C, a major milestone for the maturity and interoperability of the specification.

    Authenticators in Microsoft Edge

    Beginning with build 17723, Microsoft Edge supports the CR version of Web Authentication. Our implementation provides the most complete support for Web Authentication to date, with support for a wider variety of authenticators than other browsers.

    Windows Hello allows users to authenticate without a password on any Windows 10 device, using biometrics—face and fingerprint recognition—or a PIN number to sign in to web sites. With Windows Hello face recognition, users can log in to sites that support Web Authentication in seconds, with just a glance.

    Animation showing a purchase using Web Authentication via Windows Hello

    Users can also use external FIDO2 security keys to authenticate with a removable device and your biometrics or PIN. For websites that are not ready to move to a completely passwordless model, backwards compatibility with FIDO U2F devices can provide a strong second factor in addition to a password.

    We’re working with industry partners on lighting up the first passwordless experiences around the web. At RSA 2018, we shared a sneak peak of how these APIs could be used to approve a payment on the web with your face. Passwordless authentication experiences like this are the foundation of a world without passwords.

    Getting started

    We’re excited to get implementation into the hands of more developers to see what you build. To get started with Web Authentication in Microsoft Edge, check out more information on our implementation in the Web Authentication dev guide, or install Windows Insider Preview build 17723 or higher to try it out for yourself!

    – Angelo Liao, Program Manager, Microsoft Edge
    – Ibrahim Damlaj, Program Manager, Windows Security

    The post Introducing Web Authentication in Microsoft Edge appeared first on Microsoft Edge Dev Blog.

    Intermittent Webmaster Tools API Issues Resolved

    $
    0
    0
    The Bing Webmaster team recently received feedback that our APIs were intermittently failing, and we deeply regret any inconveniences caused from the API failures. We recognize the frustrations that this may have caused.  Upon investigation, we discovered a technical glitch which led to API call failure that is now resolved. We are very grateful to you, our users, who brought this to our attention and thank you for your continued feedback and support.

    We're Listening

    Bing and Bing Webmaster Tools are actively listening to you and we value your feedback. It’s important to how we continually improve Bing and to help notify us of potential issues. It’s easy to provide feedback: just look for the Feedback button or link at the bottom of each page. It’s in the footer or the lower-right corner and it looks something like this:
    Feedback button and link is in the bottom right corner of the footer navigation window

    We are using advances in technology to make it easier to quickly find what you are looking for – from answers to life's big questions or an item in an image you want to learn more about. At Bing, our goal is to help you get answers with less effort.  We appreciate your feedback and the more that you can send, the more we can use it to improve Bing. Have a suggestion?

    Tell us! The more feedback the merrier.

    Please let us know.
    The Bing Webmaster Tools Team

    .NET Framework July 2018 Update

    $
    0
    0

    Today, we released the July 2018 Update.

    Quality and Reliability

    This release contains the following quality and reliability improvements.

    CLR

    • Applications that rely on COM components were failing to load or run correctly because of “access denied,” “class not registered,” or “internal failure occurred for unknown reasons” errors described in 4345913. [651528]

    Note: Additional information on these improvements is not available. The VSTS bug number provided with each improvement is a unique ID that you can give Microsoft Customer Support, include in StackOverflow comments or use in web searches.

    Getting the Update

    The Update is available via Microsoft Update Catalog only.

    Microsoft Update Catalog

    You can get the update via the Microsoft Update Catalog.

    Product Version Update KB
    Windows 10 1607 (Anniversary Update) Catalog
    4346877
    .NET Framework 3.5, 4.6.2, 4.7, 4.7.1 4346877
    Windows 8.1
    Windows Server 2012 R2
    .NET Framework 3.5 Catalog
    4346745
    .NET Framework 4.5.2 Catalog
    4346408
    .NET Framework 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.1 Catalog
    4346406
    Windows Server 2012
    .NET Framework 3.5 Catalog
    4346742
    .NET Framework 4.5.2 Catalog
    4346739
    .NET Framework 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.1 Catalog
    4346405
    Windows 7
    Windows Server 2008 R2
    .NET Framework 3.5.1 Catalog
    4346744
    .NET Framework 4.5.2 Catalog
    4346410
    .NET Framework 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.1 Catalog
    4346407
    Windows Server 2008
    .NET Framework 2.0 Catalog
    4346743
    .NET Framework 4.5.2 Catalog
    4346410
    .NET Framework 4.6 Catalog
    4346407

    Previous Monthly Rollups

    The last few .NET Framework Monthly updates are listed below for your convenience:

    Azure management groups now in general availability

    $
    0
    0

    I am very excited to announce today general availability of Azure management groups to all our customers. Management groups allow you to organize your subscriptions and apply governance controls, such as Azure Policy and Role-Based Access Controls (RBAC), to the management groups. All subscriptions within a management group automatically inherit the controls applied to the management group. No matter if you have an Enterprise Agreement, Certified Solution Partner, Pay-As-You-Go, or any other type of subscription, this service gives all Azure customers enterprise-grade management at a large scale for no additional cost.

    With the GA launch of this service, we introduce new functionality to Azure that allows customers to group subscriptions together so that you can apply a policy or RBAC role to multiple subscriptions, and their resources, with one assignment. Management groups not only allow you to group subscriptions but also allows you to group other management groups to form a hierarchy. The following diagram shows an example of creating a hierarchy for governance using management groups.

    MG_overview_thumb1

    By creating a hierarchy like this you can apply a policy, for example, VM locations limited to US West Region on the group “Infrastructure Team management group” to enable internal compliance and security policies. This policy will inherit onto both EA subscriptions under that management group and will apply to all VMs under those subscriptions. As this policy inherits from the management group to the subscriptions, this security policy cannot be altered by the resource or subscription owner allowing for improved governance.

    By using management groups, you can reduce your workload and reduce the risk of error by avoiding duplicate assignments. Instead of applying multiple assignments across numerous resources and subscriptions, you can apply the one assignment on the one management group that contains the target resources. This will save time in the application of assignments, creates one point for maintenance, and allows for better controls on who can control the assignment.

    Another scenario where you would use management groups is to provide user access to multiple subscriptions. By moving multiple subscriptions under that management group, you have the ability create one RBAC assignment on the management group which will inherit that access to all the subscriptions. Without the need to script RBAC assignments over multiple subscriptions, one assignment on the management group can enable users to have access to everything they need.

    As we continue to develop management groups within Azure, new and existing services will be integrated to provide even more functionality.

    Get started today

    To get started, visit the management group documents to see the great functionality that you can start using right away. If you would rather dive right in, go right to management groups in the Azure portal and select “Start using management groups” to start your new hierarchy.  

    empty_thumb1

    Ansible 2.6: What’s new for Azure

    $
    0
    0

    Ansible 2.6 was recently released and I am excited to share with you what’s new for Azure in Ansible 2.6. In total, four new Azure modules were added in addition to over 17 enhancements to our existing modules. In 2.6 you now have the ability to natively manage:

    We published three new tutorials to the Ansible Developer Hub with this release:

    • Create and configure AKS clusters: This article shows you how to use Ansible to create and configure an Azure Kubernetes Service cluster.
    • Create and configure VMSS: This article shows you how to use Ansible to create and scale out a virtual machine scale set.
    • Deploy app to VMSS: This article shows you how to deploy a Java application to an Azure virtual machine scale set (VMSS).

    We also made a lot of enhancements to our existing modules enabling a greater range of scenarios for the deployment and management of virtual machines and networking objects. Below you can see the full changelog.

    Ansible 2.6 Azure Modules Changelog

    azure_rm_common

    • Support ADFS (Active Directory Federation Services) through ADAL (Azure AD Authentication Library)

    azure_rm_virtualnetwork

    • Set DNS server IPs in existing virtual network

    azure_networking_interface

    • Create network interface without NSG attached
    • Add network interface to Load Balancer backend pool
    • Accept security_group_name parameter when creating a security group
    • Create a new NIC associating an existing NSG
    • Create a NIC without public IP
    • Connect NICs to virtual networks in different resource groups

    azure_rm_subnet

    • Create a subnet which uses a NSG in another resource group

    azure_rm_virtualmachine_scaleset_facts

    • Improving VMSS facts response to match azure_virtualmachine_vmss input - Fix crash issue when adding data disk to a VMSS which does not have any data disk before

    azure_rm_securitygroup

    • Create rules that allow IP address prefixes

    azure_rm_loadbalancer

    • Create Internal Load Balancers
    • Support more SKU options (Basic and Standard) for Load Balancer

    azure_vm_virtualmachine

    • Create a VM with multi NICs
    • Create a VM without public IP

    azure_rm_image

    • Create an Azure image with tag

    azure_rm

    • Enable MSI and Azure CLI credential for inventory.

    Microsoft and Red Hat engineering teams continue to develop the Azure modules with the Ansible community. Join the GitHub repository to make feature requests, report issues, or contribute.

    For more information about the capabilities available, please visit the Ansible on Azure developer hub. We hope you enjoy the updates!

    New to Microsoft 365 in July—integrating apps and empowering businesses

    $
    0
    0

    This month, we hosted 17,000 attendees at Microsoft Inspire, our annual partner conference, and announced a set of new capabilities in Microsoft 365 that enhance teamwork—including a free version of Microsoft Teams. We also rolled out a number of new features across Microsoft 365 to help organizations empower their employees—including updates that streamline the management of common tasks and improve data visualization. We also want to hear your feedback, so that we can make sure these updates are relevant and useful to you.

    Here’s a look at what’s new in July.

    Microsoft Planner capabilities in SharePoint team sites—We integrated Planner with SharePoint to bring new task management capabilities directly into team sites. You can now add a plan directly to your team site from within SharePoint and embed Planner boards and chart views from those plans within SharePoint pages and news posts. This integration enables team members to easily access and interact with project tasks, while keeping important resources in a single repository.

    A screenshot of a Planner plan in SharePoint.

    Add plan information directly on pages and news posts with the new Planner web part.

    Threaded comments in Microsoft Excel—We introduced threaded comments to Excel, improving collaboration on shared documents and providing a consistent experience across Word, Excel, and PowerPoint. Threaded comments enable you to easily follow conversations taking place around content in a document and directly interact with coworkers using @mentions and nested replies. These improvements make it easier to work on spreadsheets with multiple collaborators and enhance readability and editing across devices.

    A gif showing threaded comments in Excel.

    Threaded comments make it easier to work with multiple team members in Excel.

    Visio Visuals for Microsoft Power BI—Power BI subscribers can now use Visio’s powerful visualization capabilities, right in Power BI. With Visio Visuals, you can create interactive Power BI dashboards using Power BI data sets and Visio visualization tools to quickly illustrate and compare data with charts and diagrams.

    A screenshot showing a Visio org chart next to two Power BI bar charts.

    Visio Visuals provide new and exciting ways to explore data in Power BI.

    Microsoft 365 usage analytics in Power BI—We announced the general availability of Microsoft 365 usage analytics in Power BI. Now, Microsoft 365 usage data can be connected directly to Power BI to help you better understand the services you own. We also introduced a new Teams usage report, which provides an overview of how your organization works together in Microsoft Teams, with details on various functions like chat, channels, and meetings. By using Microsoft 365 usage analytics, admins can drive improved adoption of services throughout their business and better leverage IT spend.

    LinkedIn Sales Navigator in the Microsoft 365 people card—We’re enhancing the Microsoft 365 people card to include information from LinkedIn Sales Navigator. This update allows you to surface profile information for your prospects and customers everywhere their people card appears in Office 365—helping you to build better relationships.

    A screenshot of LinkedIn Sales Navigator information directly in Outlook for the web.

    LinkedIn Sales Navigator in the Microsoft 365 people card allows you to build better relationships.

    LinkedIn Sales Navigator in the Microsoft 365 people card is rolling out soon to Microsoft 365 and Office 365 commercial customers in Outlook for the web.

    Other updates

    The post New to Microsoft 365 in July—integrating apps and empowering businesses appeared first on Microsoft 365 Blog.


    How to Convince Your Management to Upgrade to Visual Studio 2017 for C# and C++ Developers

    $
    0
    0

    Have you tried Visual Studio 2017 at home and want to use it at work? Here are eight reasons to upgrade today that you can share with your management:

    1. Faster Than Ever
    2. Efficient Code Navigation
    3. Refactorings and Quick Actions
    4. Additions to Core Editor Functionality
    5. Debugging Improvements
    6. New and Refreshed Unit Testing Experience
    7. Code Style Configuration and Enforcement
    8. C# 7.3 and MSVC Standards Conformance
    9. Upgrade today!


    Reason 1: Faster Than Ever

    We have made (and are continuing to make) substantial improvements to solution load and startup, branch switching, and unit test discovery times. Starting from Visual Studio 2017 version 15.6, solutions load on average 35% faster than in Visual Studio 2015. In fact, .NET and C++ developers opening large solutions in Visual Studio 2017 will notice their solutions load twice as fast as they did in 2015. Say goodbye to startup delays!

    We have great news about Visual Studio setup; the setup experience is faster and more lightweight than ever. Our new install experience allows you to pick and choose what you want to install–significantly reducing your install time and size, getting you up and running in Visual Studio 2017 in no time. It also installs side-by-side with previous versions of Visual Studio.


    Reason 2: Efficient Code Navigation

    We know you spend as much time understanding code as writing new code, so great navigation tools are paramount to your success as a developer. Here is how you can navigate effectively in Visual Studio 2017:

    • Search files, types, members, and symbols in Go To All (Ctrl+T or Ctrl+,) – Use this symbolic search (with category filters and individualized commands) to jump to files and symbols in your codebase without having to go through the Solution Explorer. To filter your search results to only types, for example, use the query syntax (e.g., “t myType”), the type filter button, or the command Edit.GoToType (see under Edit > Go To). Go To All search also has support for camelCase matching so you don’t have to type as many characters to get the results you need (e.g., “mf” for “myFile.cs”).
    • Group, sort, filter, and lock results in Find All References (Shift+F12) – Group your .NET and C++ reference results by document, project, definition, etc. to quickly narrow down on the results you’re looking for (whether it be identifying dead code or investigating the ramifications of a refactoring). For .NET development, view colorized symbol references in Find All References, so your results look like the code in the editor.
    • Ctrl+Click to Go To Definition – Hold down Ctrl, hover over a symbol to create a link, and click to navigate to the definition. This is especially helpful if you are fond of the mouse or if you are scrolling and exploring during a debug session.
    • Go To Implementation for .NET (Ctrl+F12) – See all implementations of a base type or member. If there is only one, we’ll jump you right there! In Visual Studio 2017, you can Go To Definition on the ‘override’ keyword in a method signature to go back to the overridden base type or member.
    • Navigate to decompiled assemblies for C# source (F12) – Enable this feature to view method bodies of external sources (rather than just signatures in Metadata As Source) when you Go To Definition. To turn this feature on, go to Tools > Options > Text Editor > C# > Advanced > Navigate to decompiled assemblies.

    Go To All showing recent files and scope to current file options highlighted

    Reason 3: Refactorings and Quick Actions

    Each release of Visual Studio 2017 brings more and more refactorings and quick fixes. Any quick action or refactoring can be triggered using Ctrl+. or Alt+Enter (for single-hand accessibility). Here are some of the ones you requested that made it in so far in .NET, across versions 15.0 through 15.8:

    • Add null-check
    • Invert if-statement
    • Resolve merge-conflict
    • Convert LINQ query to foreach
    • Convert foreach-to-for-loop and vice versa
    • Toggle between ‘var’ and the explicit type
    • Sync file and type name
    • Move type to file with same name
    • Add parameter to constructor or method from callsite
    • Convert String.Format to interpolated string
    • Make private field readonly
    • Add missing modifier and sort modifiers
    • Remove unused variable
    • Remove unnecessary parentheses

    For C++ there are a couple new quick actions to note:

    • Convert Macro to Constexpr
    • Change Declaration to use Constexpr

    Because the .NET experience in Visual Studio 2017 is built on the Roslyn language service, any developer can write their own refactoring or code analyzer to automate actions or enforce style. Read our walkthroughs to get started or check out existing community analyzers you can download.

    Invert If statement

    Reason 4: Additions to Core Editor Functionality

    We’ve added (and are working to add more) common editor features so you can quickly move around and edit your code:

    • Expand/Contract Selection (Alt+Shift+[+/-]) – Grow and shrink your selection by code constructs, i.e., from symbol to expression to statement to body to file.
    • Duplicate Line (Ctrl+D in the Default profile) – Duplicate the selected text (or the current line, if no selection) without adding anything to your Copy/Paste clipboard.
    • Multi-caret editing (Ctrl+Alt+Click and Shift+Alt+Ins) — Create multiple insertion points via Ctrl + Alt + Click or add new carets and selections that match the current selection with Shift + Alt + Ins.
    • Structure guide lines – Easily visualize the structure of your code with vertical lines between braces. Hover on the lines to see a hierarchy of code structure.
    • New Keymapping Schemes — If you’re coming from another IDE or coding environment, you can change your keyboard scheme with Tools > Options > Environment > Keyboard and use the drop down to select the new VS Code or ReSharper (VS) schemes.

    For C++ development, we have added several other editor improvements:

    • Open Folder Mode – Edit, read, build, and debug C++ code by opening folders containing source code without the need to create any solutions or projects. This includes built-in support for handling CMake projects.
    • Template IntelliSense – The editor now displays a ‘Template Bar’ which allows C++ developers to provide sample template arguments for improved IntelliSense in class/function templates.
    • Macro Expansion in Quick Info – Hovering over a macro will display the actual expansion of the macro that the preprocessor will replace during the first stage of compilation.

    CPP Template IntelliSense

    Reason 5: Debugging Improvements

    The Visual Studio 2017 debugger allows you to diagnose issues faster by surfacing critical information and functionality without requiring new breakpoints and a restart of your debugging session.

    • The new Exception Helper – See which variable or member is returning null when a NullReferenceException is thrown, and tweak exception configuration options.
    • Step Back debugging (Enterprise only) – Go back to previous breakpoints or steps and view the state of the application as it was in the past.
    • Run To Click – Hover at the beginning of a line of code and click the green play button to run the debugger to your location without having to hunt down the yellow instruction pointer.
    • Just My Code stepping for C++ – Step over non-user code, so you don’t have to spend your time stepping over countless lines of library code that you’re not interested in.


    Reason 6: New and Refreshed Unit Testing Experience

    We buckled down on providing a fast and productive unit testing experience for MSTest (v1.0 and 2.0), NUnit, XUnit, Google Test, and Boost frameworks:

    • Test Explorer Performance Improvements – Test discovery is fast in Visual Studio 2017 and we will instantly display newly added tests (without requiring a build).
    • Test Explorer Hierarchy View — We’ve also added a hierarchy view of your unit tests so that you can explore and run them by project, class, etc. Test runs now also have responsive icons so you can see what tests are currently executing and pending to execute.
    • Live Unit Testing for .NET (Enterprise only) – As you type, Live Unit Testing identifies which unit tests are impacted by your code change, runs those tests, and updates icons in the editor to display the results of the test run. You can configure what tests are discovered and run in your “live test set” by including or excluding test projects or individual tests. To enable Live Unit Testing, go to Test > Live Unit Testing > Start.
    • Google Test and Boost support for C++ — The Google Test and Boost.Test unit testing frameworks are completely supported and integrated with Visual Studio’s testing tools.

    Test Explorer showing Test Heirarchy

    Reason 7: Code Style Configuration and Enforcement

    Visual Studio 2017 enables individuals and teams to drive consistency across their codebase with coding convention configuration and enforcement.

    • Individual Coding Conventions for .NET – Configure your coding preferences for your machine in Tools > Options > Text Editor > C# | Basic > Code Style.
    • Team Coding Conventions for .NET – Use .editorconfig (we worked with the community to extend the open-source file format to work with .NET code style) to codify your conventions and have them enforced in Visual Studio. Say goodbye to managing your rules from a file share!
    • Fix All Violations – Use the lightbulb menu (Ctrl+. or Alt+Enter) and select the Document, Project, or Solution scope from the preview dialog to fix all violations of a single rule.
    • One-click Code Cleanup for .NET —In Visual Studio 2017 15.8, you can perform additional code cleanup with Format Document (Ctlr+K,D) by configuring it in Tools > Options > Text Editor > C# > Code Style > Formatting and checking fixes like Remove and Sort usings.
    • ClangFormat for C++ – In addition to EditorConfig, ClangFormat is supported, giving C++ developers the ability to style and format their code based on a set of rules that can be configured in a .clang-format or _clang-format file.


    Reason 8: C# 7.3 and MSVC Standards Conformance

    C# 7.0 ships with Visual Studio 2017 by default, bringing language features like tuples, pattern-matching, and out var to help you work with data and make your code more readable. You can also upgrade your project to be on the “latest minor” version of C# and take advantage of features in our point-releases like: async Main, Span, Enum constraints, and more!

    As of Visual Studio 2017 version 15.7, MSVC compiler toolset conforms to the C++ Standard up to and including C++17, with minor exceptions. The C++ team worked to significantly overhaul the compiler, making it far easier to implement modern C++ features. Additionally, we added the C++ Core Guidelines Check extension (CppCoreCheck). This extension is designed to make it easy to adopt C++ Core Guidelines and adopt utilities from the Guidelines Support Library.

    Migration to Visual Studio 2017 for C++ is easier than ever before. Visual Studio C++ 2017 is binary compatible with Visual Studio C++ 2015, so there is no need to rebuild your 2015 component. Furthermore, the decoupling of toolsets means that you can use your toolset from 2013 or later.


    Upgrade Today

    Upgrading may be extremely easy for your team–if you and your team are on Visual Studio Community or have an EA/Subscription, you already have access to a Visual Studio 2017 license today. To learn more about how to upgrade, visit our upgrade site. To learn more about how you can be productive in Visual Studio 2017, check out the productivity guide for .NET developers for a comprehensive overview of our tools and features.

    Give Us Feedback

    We’re releasing updates to Visual Studio at a faster cadence than ever before so that we can unblock you on any issues you may have and evolve and create features to make you more productive in your everyday workflow.

    Use the Send Feedback button inside Visual Studio to have direct access to the product team (we look at all of them!) and to easily share memory dumps and traces so that we can more quickly investigate issues with performance you may have. Also use button to request productivity features you need to code with ease and confidence. We are here to help you upgrade!

    Kasey Uhlenhuth, Program Manager, Visual Studio and .NET
    @kuhlenhuth

    Kasey Uhlenhuth is a Program Manager on the .NET and Visual Studio team working to improve developer productivity.

    Nick Uhlenhuth, Program Manager, Visual Studio and .NET
    @nickuhlenhuth

    Nick Uhlenhuth is a Program Manager on the Visual Studio team responsible for C++ IntelliSense and Productivity features.

    Windows 10 SDK Preview Build 17723 available now!

    $
    0
    0

    Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 17723 or greater). The Preview SDK Build 17723 contains bug fixes and under development changes to the API surface area.

    The Preview SDK can be downloaded from developer section on Windows Insider.

    For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

    Things to note:

    • This build works in conjunction with previously released SDKs and Visual Studio 2017. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1803 or earlier to the store.
    • The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2017 here.
    • This build of the Windows SDK will only install on Windows 10 Insider Preview builds.
    • In order to assist with script access to the SDK, the ISO will also be able to be accessed through the following URL: https://go.microsoft.com/fwlink/?prd=11966&pver=1.0&plcid=0x409&clcid=0x409&ar=Flight&sar=Sdsurl&o1=17723 once the static URL is published.

    C++/WinRT Update for build 17709 and beyond:

    This update introduces many improvements and fixes for C++/WinRT. Notably, it introduces the ability to build C++/WinRT without any dependency on the Windows SDK. This isn’t particularly interesting to the OS developer, but even in the OS repo it provides benefits because it does not itself include any Windows headers. Thus, a developer will typically pull in fewer or no dependencies inadvertently. This also means a dramatic reduction in the number of macros that a C++/WinRT developer must guard against. Removing the dependency on the Windows headers means that C++/WinRT is more portable and standards compliant and furthers our efforts to make it a cross-compiler and cross-platform library. It also means that the C++/WinRT headers will never be mangled by macros. If you previously relied on C++/WinRT to include various Windows headers that you will now have to include them yourself. It has always been good practice to always include any headers you depend on explicitly and not rely on another library to include them for you.

    Highlights

    Support get_strong and get_weak to create delegates: This update allows a developer to use either get_strong or get_weak instead of a raw this pointer when creating a delegate pointing to a member function.

    Add async cancellation callback: The most frequently requested feature for C++/WinRT’s coroutine support has been the addition of a cancellation callback.

    Simplify the use of APIs expecting IBuffer parameters: Although most APIs prefer collections or arrays, enough APIs rely on IBuffer that it should be easier to use such APIs from C++. This update provides direct access to the data behind an IBuffer implementation using the same data naming convention used by the C++ standard library containers. This also avoids colliding with metadata names that conventionally begin with an uppercase letter.

    Conformance: Improved support for Clang and Visual C++’s stricter conformance modes.

    Improved code gen: Various improvements to reduce code size, improve inlining, and optimize factory caching.

    Remove unnecessary recursion: When the command line refers to a folder rather than a specific winmd, cppwinrt will no longer search recursively for winmd files. It causes performance problems in the OS build and can lead to usage errors that are hard to diagnose when developers inadvertently cause cppwinrt to consume more winmds than expected. The cppwinrt compiler also now handles duplicates more intelligently, making it more resilient to user error and poorly-formed winmd files.

    Declare both WINRT_CanUnloadNow and WINRT_GetActivationFactory in base.h: Callers don’t need to declare them directly. Their signatures have also changed, amounting to a breaking change. The declarations alleviate most of the pain of this change. The change is necessitated by the fact that C++/WinRT no longer depends on the Windows headers and this change removes the dependency on the types from the Windows headers.

    Harden smart pointers: The event revokers didn’t revoke when move-assigned a new value. This lead me to take a closer look at the smart pointer classes and I noticed that they were not reliably handling self-assignment. This is rooted in the com_ptr class template that most of the others rely on. I fixed com_ptr and updated the event revokers to handle move semantics correctly to ensure that they revoke upon assignment. The handle class template has also been hardened by the removal of the implicit constructor that made it easy to write incorrect code. This also turned bugs in the OS into compiler errors fixed in this PR.

    Breaking Changes

    Support for non-WinRT interfaces is disabled by default. To enable, simply #include <unknwn.h> before any C++/WinRT headers.

    winrt::get_abi(winrt::hstring) now returns void* instead of HSTRING. Code requiring the HSTRING ABI can simply use a static_cast.

    winrt::put_abi(winrt::hstring) returns void** instead of HSTRING*. Code requiring the HSTRING ABI can simply use a reinterpret_cast.

    HRESULT is now projected as winrt::hresult. Code requiring an HRESULT can simply static_cast if you need to do type checking or support type traits, but it is otherwise convertible as long as <unknwn.h> is included first.

    GUID is now projected as winrt::guid. Code implementing APIs with GUID parameters must use winrt::guid instead, but it is otherwise convertible as long as <unknwn.h> is included first.

    The signatures of WINRT_CanUnloadNow and WINRT_GetActivationFactory has changed. Code must not declare these functions at all and instead include winrt/base.h to include their declarations.

    The winrt::handle constructor is now explicit. Code assigning a raw handle value must call the attach method instead.

    winrt::clock::from_FILETIME has been deprecated. Code should use winrt::clock::from_file_time instead.

    What’s New:

    MSIX Support

    It’s finally here! You can now package your applications as MSIX! These applications can be installed and run on any device with 17682 build or later.

    To package your application with MSIX, use the MakeAppx tool. To install the application – just click on the MSIX file. To understand more about MSIX, watch this introductory video: link

    Feedback and comments are welcome on our MSIX community: http://aka.ms/MSIXCommunity

    MSIX is not currently supported by the App Certification Kit nor the Microsoft Store at this time.

    MC.EXE

    We’ve made some important changes to the C/C++ ETW code generation of mc.exe (Message Compiler):

    The “-mof” parameter is deprecated. This parameter instructs MC.exe to generate ETW code that is compatible with Windows XP and earlier. Support for the “-mof” parameter will be removed in a future version of mc.exe.

    As long as the “-mof” parameter is not used, the generated C/C++ header is now compatible with both kernel-mode and user-mode, regardless of whether “-km” or “-um” was specified on the command line. The header will use the _ETW_KM_ macro to automatically determine whether it is being compiled for kernel-mode or user-mode and will call the appropriate ETW APIs for each mode.

    • The only remaining difference between “-km” and “-um” is that the EventWrite[EventName] macros generated with “-km” have an Activity ID parameter while the EventWrite[EventName] macros generated with “-um” do not have an Activity ID parameter.

    The EventWrite[EventName] macros now default to calling EventWriteTransfer (user mode) or EtwWriteTransfer (kernel mode). Previously, the EventWrite[EventName] macros defaulted to calling EventWrite (user mode) or EtwWrite (kernel mode).

    • The generated header now supports several customization macros. For example, you can set the MCGEN_EVENTWRITETRANSFER macro if you need the generated macros to call something other than EventWriteTransfer.
    • The manifest supports new attributes.
      • Event “name”: non-localized event name.
      • Event “attributes”: additional key-value metadata for an event such as filename, line number, component name, function name.
      • Event “tags”: 28-bit value with user-defined semantics (per-event).
      • Field “tags”: 28-bit value with user-defined semantics (per-field – can be applied to “data” or “struct” elements).
    • You can now define “provider traits” in the manifest (e.g. provider group). If provider traits are used in the manifest, the EventRegister[ProviderName] macro will automatically register them.
    • MC will now report an error if a localized message file is missing a string. (Previously MC would silently generate a corrupt message resource.)
    • MC can now generate Unicode (utf-8 or utf-16) output with the “-cp utf-8” or “-cp utf-16” parameters.

    Known Issues:

    The SDK headers are generated with types in the “ABI” namespace. This is done to avoid conflicts with C++/CX and C++/WinRT clients that need to consume types directly at the ABI layer[1]. By default, types emitted by MIDL are *not* put in the ABI namespace, however this has the potential to introduce conflicts from teams attempting to consume ABI types from Windows WinRT MIDL generated headers and non-Windows WinRT MIDL generated headers (this is especially challenging if the non-Windows header references Windows types).

    To ensure that developers have a consistent view of the WinRT API surface, validation has been added to the generated headers to ensure that the ABI prefix is consistent between the Windows headers and user generated headers. If you encounter an error like:

    5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): error C2220: warning treated as error – no ‘object’ file generated

    5>c:program files (x86)windows kits10include10.0.17687.0winrtwindows.foundation.h(83): warning C4005: ‘CHECK_NS_PREFIX_STATE’: macro redefinition

    5>g:<PATH TO YOUR HEADER HERE>(41): note: see previous definition of ‘CHECK_NS_PREFIX_STATE’

    It means that some of your MIDL generated headers are inconsistent with the system generated headers.

    There are two ways to fix this:

    • Preferred: Compile your IDL file with the /ns_prefix MIDL command line switch. This will cause all your types to be moved to the ABI namespace consistent with the Windows headers. This may require code changes in your code however.
    • Alternate: Add #define DISABLE_NS_PREFIX_CHECKS before including the Windows headers. This will suppress the validation.

    API Updates, Additions and Removals

    When targeting new APIs, consider writing your app to be adaptive in order to run correctly on the widest number of Windows 10 devices. Please see Dynamically detecting features with API contracts (10 by 10) for more information.

    The following APIs have been added to the platform since the release of 17134.  The APIs listed below have been removed.

    Additions:

    namespace Windows.AI.MachineLearning {
      public interface ILearningModelFeatureDescriptor
      public interface ILearningModelFeatureValue
      public interface ILearningModelOperatorProvider
      public sealed class ImageFeatureDescriptor : ILearningModelFeatureDescriptor
      public sealed class ImageFeatureValue : ILearningModelFeatureValue
      public interface ITensor : ILearningModelFeatureValue
      public sealed class LearningModel : IClosable
      public sealed class LearningModelBinding : IIterable<IKeyValuePair<string, object>>, IMapView<string, object>
      public sealed class LearningModelDevice
      public enum LearningModelDeviceKind
      public sealed class LearningModelEvaluationResult
      public enum LearningModelFeatureKind
      public sealed class LearningModelSession : IClosable
      public struct MachineLearningContract
      public sealed class MapFeatureDescriptor : ILearningModelFeatureDescriptor
      public sealed class SequenceFeatureDescriptor : ILearningModelFeatureDescriptor
      public sealed class TensorBoolean : ILearningModelFeatureValue, ITensor
      public sealed class TensorDouble : ILearningModelFeatureValue, ITensor
      public sealed class TensorFeatureDescriptor : ILearningModelFeatureDescriptor
      public sealed class TensorFloat : ILearningModelFeatureValue, ITensor
      public sealed class TensorFloat16Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorInt16Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorInt32Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorInt64Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorInt8Bit : ILearningModelFeatureValue, ITensor
      public enum TensorKind
      public sealed class TensorString : ILearningModelFeatureValue, ITensor
      public sealed class TensorUInt16Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorUInt32Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorUInt64Bit : ILearningModelFeatureValue, ITensor
      public sealed class TensorUInt8Bit : ILearningModelFeatureValue, ITensor
    }
    namespace Windows.ApplicationModel {
      public sealed class AppInstallerInfo
      public sealed class LimitedAccessFeatureRequestResult
      public static class LimitedAccessFeatures
      public enum LimitedAccessFeatureStatus
      public sealed class Package {
        IAsyncOperation<PackageUpdateAvailabilityResult> CheckUpdateAvailabilityAsync();
        AppInstallerInfo GetAppInstallerInfo();
      }
      public enum PackageUpdateAvailability
      public sealed class PackageUpdateAvailabilityResult
    }
    namespace Windows.ApplicationModel.Calls {
      public sealed class VoipCallCoordinator {
        IAsyncOperation<VoipPhoneCallResourceReservationStatus> ReserveCallResourcesAsync();
      }
    }
    namespace Windows.ApplicationModel.Chat {
      public static class ChatCapabilitiesManager {
        public static IAsyncOperation<ChatCapabilities> GetCachedCapabilitiesAsync(string address, string transportId);
        public static IAsyncOperation<ChatCapabilities> GetCapabilitiesFromNetworkAsync(string address, string transportId);
      }
      public static class RcsManager {
        public static event EventHandler<object> TransportListChanged;
      }
    }
    namespace Windows.ApplicationModel.DataTransfer {
      public static class Clipboard {
        public static event EventHandler<ClipboardHistoryChangedEventArgs> HistoryChanged;
        public static event EventHandler<object> HistoryEnabledChanged;
        public static event EventHandler<object> RoamingEnabledChanged;
        public static bool ClearHistory();
        public static bool DeleteItemFromHistory(ClipboardHistoryItem item);
        public static IAsyncOperation<ClipboardHistoryItemsResult> GetHistoryItemsAsync();
        public static bool IsHistoryEnabled();
        public static bool IsRoamingEnabled();
        public static bool SetContentWithOptions(DataPackage content, ClipboardContentOptions options);
        public static SetHistoryItemAsContentStatus SetHistoryItemAsContent(ClipboardHistoryItem item);
      }
      public sealed class ClipboardContentOptions
      public sealed class ClipboardHistoryChangedEventArgs
      public sealed class ClipboardHistoryItem
      public sealed class ClipboardHistoryItemsResult
      public enum ClipboardHistoryItemsResultStatus
      public sealed class DataPackagePropertySetView : IIterable<IKeyValuePair<string, object>>, IMapView<string, object> {
        bool IsFromRoamingClipboard { get; }
        string SourceDisplayName { get; }
      }
      public enum SetHistoryItemAsContentStatus
    }
    namespace Windows.ApplicationModel.Store.Preview {
      public enum DeliveryOptimizationDownloadMode
      public enum DeliveryOptimizationDownloadModeSource
      public sealed class DeliveryOptimizationSettings
      public static class StoreConfiguration {
        public static bool IsPinToDesktopSupported();
        public static bool IsPinToStartSupported();
        public static bool IsPinToTaskbarSupported();
        public static void PinToDesktop(string appPackageFamilyName);
        public static void PinToDesktopForUser(User user, string appPackageFamilyName);
      }
    }
    namespace Windows.ApplicationModel.Store.Preview.InstallControl {
      public enum AppInstallationToastNotificationMode
      public sealed class AppInstallItem {
        AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
        AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
        bool PinToDesktopAfterInstall { get; set; }
        bool PinToStartAfterInstall { get; set; }
        bool PinToTaskbarAfterInstall { get; set; }
      }
      public sealed class AppInstallManager {
        bool CanInstallForAllUsers { get; }
      }
      public sealed class AppInstallOptions {
        string CampaignId { get; set; }
        AppInstallationToastNotificationMode CompletedInstallToastNotificationMode { get; set; }
        string ExtendedCampaignId { get; set; }
        bool InstallForAllUsers { get; set; }
       AppInstallationToastNotificationMode InstallInProgressToastNotificationMode { get; set; }
        bool PinToDesktopAfterInstall { get; set; }
        bool PinToStartAfterInstall { get; set; }
        bool PinToTaskbarAfterInstall { get; set; }
        bool StageButDoNotInstall { get; set; }
      }
      public sealed class AppUpdateOptions {
        bool AutomaticallyDownloadAndInstallUpdateIfFound { get; set; }
      }
    }
    namespace Windows.ApplicationModel.UserActivities {
      public sealed class UserActivity {
        bool IsRoamable { get; set; }
      }
    }
    namespace Windows.Data.Text {
      public sealed class TextPredictionGenerator {
        CoreTextInputScope InputScope { get; set; }
        IAsyncOperation<IVectorView<string>> GetCandidatesAsync(string input, uint maxCandidates, TextPredictionOptions predictionOptions, IIterable<string> previousStrings);
        IAsyncOperation<IVectorView<string>> GetNextWordCandidatesAsync(uint maxCandidates, IIterable<string> previousStrings);
      }
      public enum TextPredictionOptions : uint
    }
    namespace Windows.Devices.Display.Core {
      public sealed class DisplayAdapter
      public enum DisplayBitsPerChannel : uint
      public sealed class DisplayDevice
      public enum DisplayDeviceCapability
      public sealed class DisplayFence
      public sealed class DisplayManager : IClosable
      public sealed class DisplayManagerChangedEventArgs
      public sealed class DisplayManagerDisabledEventArgs
      public sealed class DisplayManagerEnabledEventArgs
      public enum DisplayManagerOptions : uint
      public sealed class DisplayManagerPathsFailedOrInvalidatedEventArgs
      public enum DisplayManagerResult
      public sealed class DisplayManagerResultWithState
      public sealed class DisplayModeInfo
      public enum DisplayModeQueryOptions : uint
      public sealed class DisplayPath
      public enum DisplayPathScaling
      public enum DisplayPathStatus
      public struct DisplayPresentationRate
      public sealed class DisplayPrimaryDescription
      public enum DisplayRotation
      public sealed class DisplayScanout
      public sealed class DisplaySource
      public sealed class DisplayState
      public enum DisplayStateApplyOptions : uint
      public enum DisplayStateFunctionalizeOptions : uint
      public sealed class DisplayStateOperationResult
      public enum DisplayStateOperationStatus
      public sealed class DisplaySurface
      public sealed class DisplayTarget
      public enum DisplayTargetPersistence
      public sealed class DisplayTask
      public sealed class DisplayTaskPool
      public enum DisplayTaskSignalKind
      public sealed class DisplayView
      public sealed class DisplayWireFormat
      public enum DisplayWireFormatColorSpace
      public enum DisplayWireFormatEotf
      public enum DisplayWireFormatHdrMetadata
      public enum DisplayWireFormatPixelEncoding
    }
    namespace Windows.Devices.Enumeration {
      public enum DeviceInformationKind {
        DevicePanel = 8,
      }
      public sealed class DeviceInformationPairing {
        public static bool TryRegisterForAllInboundPairingRequestsWithProtectionLevel(DevicePairingKinds pairingKindsSupported, DevicePairingProtectionLevel minProtectionLevel);
      }
    }
    namespace Windows.Devices.Enumeration.Pnp {
      public enum PnpObjectType {
        DevicePanel = 8,
      }
    }
    namespace Windows.Devices.Lights {
      public sealed class LampArray
      public enum LampArrayKind
      public sealed class LampInfo
      public enum LampPurposes : uint
    }
    namespace Windows.Devices.Lights.Effects {
      public interface ILampArrayEffect
      public sealed class LampArrayBitmapEffect : ILampArrayEffect
      public sealed class LampArrayBitmapRequestedEventArgs
      public sealed class LampArrayBlinkEffect : ILampArrayEffect
      public sealed class LampArrayColorRampEffect : ILampArrayEffect
      public sealed class LampArrayCustomEffect : ILampArrayEffect
      public enum LampArrayEffectCompletionBehavior
      public sealed class LampArrayEffectPlaylist : IIterable<ILampArrayEffect>, IVectorView<ILampArrayEffect>
      public enum LampArrayEffectStartMode
      public enum LampArrayRepetitionMode
      public sealed class LampArraySolidEffect : ILampArrayEffect
      public sealed class LampArrayUpdateRequestedEventArgs
    }
    namespace Windows.Devices.PointOfService {
      public sealed class BarcodeScannerCapabilities {
        bool IsVideoPreviewSupported { get; }
      }
      public sealed class ClaimedBarcodeScanner : IClosable {
        event TypedEventHandler<ClaimedBarcodeScanner, ClaimedBarcodeScannerClosedEventArgs> Closed;
      }
      public sealed class ClaimedBarcodeScannerClosedEventArgs
      public sealed class ClaimedCashDrawer : IClosable {
        event TypedEventHandler<ClaimedCashDrawer, ClaimedCashDrawerClosedEventArgs> Closed;
      }
      public sealed class ClaimedCashDrawerClosedEventArgs
      public sealed class ClaimedLineDisplay : IClosable {
        event TypedEventHandler<ClaimedLineDisplay, ClaimedLineDisplayClosedEventArgs> Closed;
      }
      public sealed class ClaimedLineDisplayClosedEventArgs
      public sealed class ClaimedMagneticStripeReader : IClosable {
        event TypedEventHandler<ClaimedMagneticStripeReader, ClaimedMagneticStripeReaderClosedEventArgs> Closed;
      }
      public sealed class ClaimedMagneticStripeReaderClosedEventArgs
      public sealed class ClaimedPosPrinter : IClosable {
        event TypedEventHandler<ClaimedPosPrinter, ClaimedPosPrinterClosedEventArgs> Closed;
      }
      public sealed class ClaimedPosPrinterClosedEventArgs
    }
    namespace Windows.Devices.PointOfService.Provider {
      public sealed class BarcodeScannerDisableScannerRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerEnableScannerRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerFrameReader : IClosable
      public sealed class BarcodeScannerFrameReaderFrameArrivedEventArgs
      public sealed class BarcodeScannerGetSymbologyAttributesRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerHideVideoPreviewRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerProviderConnection : IClosable {
        IAsyncOperation<BarcodeScannerFrameReader> CreateFrameReaderAsync();
        IAsyncOperation<BarcodeScannerFrameReader> CreateFrameReaderAsync(BitmapPixelFormat preferredFormat);
        IAsyncOperation<BarcodeScannerFrameReader> CreateFrameReaderAsync(BitmapPixelFormat preferredFormat, BitmapSize preferredSize);
      }
      public sealed class BarcodeScannerSetActiveSymbologiesRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
     public sealed class BarcodeScannerSetSymbologyAttributesRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerStartSoftwareTriggerRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerStopSoftwareTriggerRequest {
        IAsyncAction ReportFailedAsync(int reason);
        IAsyncAction ReportFailedAsync(int reason, string failedReasonDescription);
      }
      public sealed class BarcodeScannerVideoFrame : IClosable
    }
    namespace Windows.Devices.Sensors {
      public sealed class HingeAngleReading
      public sealed class HingeAngleSensor
      public sealed class HingeAngleSensorReadingChangedEventArgs
      public sealed class SimpleOrientationSensor {
        public static IAsyncOperation<SimpleOrientationSensor> FromIdAsync(string deviceId);
        public static string GetDeviceSelector();
      }
    }
    namespace Windows.Devices.SmartCards {
      public static class KnownSmartCardAppletIds
      public sealed class SmartCardAppletIdGroup {
        string Description { get; set; }
        IRandomAccessStreamReference Logo { get; set; }
        ValueSet Properties { get; }
        bool SecureUserAuthenticationRequired { get; set; }
      }
      public sealed class SmartCardAppletIdGroupRegistration {
        string SmartCardReaderId { get; }
        IAsyncAction SetPropertiesAsync(ValueSet props);
      }
    }
    namespace Windows.Devices.WiFi {
      public enum WiFiPhyKind {
        HE = 10,
      }
    }
    namespace Windows.Foundation {
      public static class GuidHelper
    }
    namespace Windows.Globalization {
      public static class CurrencyIdentifiers {
        public static string MRU { get; }
        public static string SSP { get; }
        public static string STN { get; }
        public static string VES { get; }
      }
    }
    namespace Windows.Graphics.Capture {
      public sealed class Direct3D11CaptureFramePool : IClosable {
        public static Direct3D11CaptureFramePool CreateFreeThreaded(IDirect3DDevice device, DirectXPixelFormat pixelFormat, int numberOfBuffers, SizeInt32 size);
      }
      public sealed class GraphicsCaptureItem {
        public static GraphicsCaptureItem CreateFromVisual(Visual visual);
      }
    }
    namespace Windows.Graphics.Display.Core {
      public enum HdmiDisplayHdrOption {
        DolbyVisionLowLatency = 3,
      }
      public sealed class HdmiDisplayMode {
        bool IsDolbyVisionLowLatencySupported { get; }
      }
    }
    namespace Windows.Graphics.Holographic {
      public sealed class HolographicCamera {
        bool IsHardwareContentProtectionEnabled { get; set; }
        bool IsHardwareContentProtectionSupported { get; }
      }
      public sealed class HolographicQuadLayerUpdateParameters {
        bool CanAcquireWithHardwareProtection { get; }
        IDirect3DSurface AcquireBufferToUpdateContentWithHardwareProtection();
      }
    }
    namespace Windows.Graphics.Imaging {
      public sealed class BitmapDecoder : IBitmapFrame, IBitmapFrameWithSoftwareBitmap {
        public static Guid HeifDecoderId { get; }
        public static Guid WebpDecoderId { get; }
      }
      public sealed class BitmapEncoder {
        public static Guid HeifEncoderId { get; }
      }
    }
    namespace Windows.Management.Deployment {
      public enum DeploymentOptions : uint {
        ForceUpdateFromAnyVersion = (uint)262144,
      }
      public sealed class PackageManager {
        IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> DeprovisionPackageForAllUsersAsync(string packageFamilyName);
      }
      public enum RemovalOptions : uint {
        RemoveForAllUsers = (uint)524288,
      }
    }
    namespace Windows.Management.Policies {
      public static class NamedPolicy {
        public static IAsyncAction ClearAllPoliciesAsync();
        public static IAsyncAction ClearAllPoliciesAsync(string accountId);
        public static NamedPolicySetter TryCreatePolicySetter(string accountId);
        public static NamedPolicySetter TryCreatePolicySetterForUser(User user, string accountId);
      }
      public sealed class NamedPolicySetter
    }
    namespace Windows.Media.Audio {
      public sealed class CreateAudioDeviceInputNodeResult {
        HResult ExtendedError { get; }
      }
      public sealed class CreateAudioDeviceOutputNodeResult {
        HResult ExtendedError { get; }
      }
      public sealed class CreateAudioFileInputNodeResult {
        HResult ExtendedError { get; }
      }
      public sealed class CreateAudioFileOutputNodeResult {
        HResult ExtendedError { get; }
      }
      public sealed class CreateAudioGraphResult {
        HResult ExtendedError { get; }
      }
      public sealed class CreateMediaSourceAudioInputNodeResult {
        HResult ExtendedError { get; }
      }
      public enum MixedRealitySpatialAudioFormatPolicy
      public sealed class SetDefaultSpatialAudioFormatResult
      public enum SetDefaultSpatialAudioFormatStatus
      public sealed class SpatialAudioDeviceConfiguration
      public sealed class SpatialAudioFormatConfiguration
      public static class SpatialAudioFormatSubtype
    }
    namespace Windows.Media.Control {
      public sealed class CurrentSessionChangedEventArgs
      public sealed class GlobalSystemMediaTransportControlsSession
      public sealed class GlobalSystemMediaTransportControlsSessionManager
      public sealed class GlobalSystemMediaTransportControlsSessionMediaProperties
      public sealed class GlobalSystemMediaTransportControlsSessionPlaybackControls
      public sealed class GlobalSystemMediaTransportControlsSessionPlaybackInfo
      public enum GlobalSystemMediaTransportControlsSessionPlaybackStatus
      public sealed class GlobalSystemMediaTransportControlsSessionTimelineProperties
     public sealed class MediaPropertiesChangedEventArgs
      public sealed class PlaybackInfoChangedEventArgs
      public sealed class SessionsChangedEventArgs
      public sealed class TimelinePropertiesChangedEventArgs
    }
    namespace Windows.Media.Core {
      public sealed class MediaStreamSample {
        IDirect3DSurface Direct3D11Surface { get; }
        public static MediaStreamSample CreateFromDirect3D11Surface(IDirect3DSurface surface, TimeSpan timestamp);
      }
    }
    namespace Windows.Media.Devices.Core {
      public sealed class CameraIntrinsics {
        public CameraIntrinsics(Vector2 focalLength, Vector2 principalPoint, Vector3 radialDistortion, Vector2 tangentialDistortion, uint imageWidth, uint imageHeight);
      }
    }
    namespace Windows.Media.Import {
      public enum PhotoImportContentTypeFilter {
        ImagesAndVideosFromCameraRoll = 3,
      }
      public sealed class PhotoImportItem {
        string Path { get; }
      }
    }
    namespace Windows.Media.MediaProperties {
      public sealed class ImageEncodingProperties : IMediaEncodingProperties {
        public static ImageEncodingProperties CreateHeif();
      }
      public static class MediaEncodingSubtypes {
        public static string Heif { get; }
      }
    }
    namespace Windows.Media.Protection.PlayReady {
      public static class PlayReadyStatics {
        public static IReference<DateTime> HardwareDRMDisabledAtTime { get; }
        public static IReference<DateTime> HardwareDRMDisabledUntilTime { get; }
        public static void ResetHardwareDRMDisabled();
      }
    }
    namespace Windows.Media.Streaming.Adaptive {
      public enum AdaptiveMediaSourceResourceType {
        MediaSegmentIndex = 5,
      }
    }
    namespace Windows.Networking.BackgroundTransfer {
      public enum BackgroundTransferPriority {
        Low = 2,
      }
    }
    namespace Windows.Networking.Connectivity {
      public sealed class ConnectionProfile {
        bool CanDelete { get; }
        IAsyncOperation<ConnectionProfileDeleteStatus> TryDeleteAsync();
      }
      public enum ConnectionProfileDeleteStatus
    }
    namespace Windows.Networking.NetworkOperators {
      public enum ESimOperationStatus {
        CardGeneralFailure = 13,
        ConfirmationCodeMissing = 14,
        EidMismatch = 18,
        InvalidMatchingId = 15,
        NoCorrespondingRequest = 23,
        NoEligibleProfileForThisDevice = 16,
        OperationAborted = 17,
        OperationProhibitedByProfileClass = 21,
        ProfileNotAvailableForNewBinding = 19,
        ProfileNotPresent = 22,
        ProfileNotReleasedByOperator = 20,
      }
    }
    namespace Windows.Perception {
      public sealed class PerceptionTimestamp {
        TimeSpan SystemRelativeTargetTime { get; }
      }
      public static class PerceptionTimestampHelper {
        public static PerceptionTimestamp FromSystemRelativeTargetTime(TimeSpan targetTime);
      }
    }
    namespace Windows.Perception.Spatial {
      public sealed class SpatialAnchorExporter
      public enum SpatialAnchorExportPurpose
      public sealed class SpatialAnchorExportSufficiency
      public sealed class SpatialLocation {
        Vector3 AbsoluteAngularAccelerationAxisAngle { get; }
        Vector3 AbsoluteAngularVelocityAxisAngle { get; }
      }
    }
    namespace Windows.Perception.Spatial.Preview {
      public static class SpatialGraphInteropPreview
    }
    namespace Windows.Security.DataProtection {
      public enum UserDataAvailability
      public sealed class UserDataAvailabilityStateChangedEventArgs
      public sealed class UserDataBufferUnprotectResult
      public enum UserDataBufferUnprotectStatus
      public sealed class UserDataProtectionManager
      public sealed class UserDataStorageItemProtectionInfo
      public enum UserDataStorageItemProtectionStatus
    }
    namespace Windows.Services.Cortana {
      public sealed class CortanaActionableInsights
      public sealed class CortanaActionableInsightsOptions
    }
    namespace Windows.Services.Store {
      public sealed class StoreAppLicense {
        bool IsDiscLicense { get; }
      }
      public sealed class StoreContext {
        IAsyncOperation<StoreRateAndReviewResult> RequestRateAndReviewAppAsync();
        IAsyncOperation<IVectorView<StoreQueueItem>> SetInstallOrderForAssociatedStoreQueueItemsAsync(IIterable<StoreQueueItem> items);
      }
      public sealed class StoreQueueItem {
        IAsyncAction CancelInstallAsync();
        IAsyncAction PauseInstallAsync();
        IAsyncAction ResumeInstallAsync();
      }
      public sealed class StoreRateAndReviewResult
      public enum StoreRateAndReviewStatus
    }
    namespace Windows.Storage.Provider {
      public enum StorageProviderHydrationPolicyModifier : uint {
        AutoDehydrationAllowed = (uint)4,
      }
      public sealed class StorageProviderSyncRootInfo {
        Guid ProviderId { get; set; }
      }
    }
    namespace Windows.System {
      public sealed class AppUriHandlerHost
      public sealed class AppUriHandlerRegistration
      public sealed class AppUriHandlerRegistrationManager
      public static class Launcher {
        public static IAsyncOperation<bool> LaunchFolderPathAsync(string path);
        public static IAsyncOperation<bool> LaunchFolderPathAsync(string path, FolderLauncherOptions options);
        public static IAsyncOperation<bool> LaunchFolderPathForUserAsync(User user, string path);
        public static IAsyncOperation<bool> LaunchFolderPathForUserAsync(User user, string path, FolderLauncherOptions options);
      }
    }
    namespace Windows.System.Preview {
      public enum HingeState
      public sealed class TwoPanelHingedDevicePosturePreview
      public sealed class TwoPanelHingedDevicePosturePreviewReading
      public sealed class TwoPanelHingedDevicePosturePreviewReadingChangedEventArgs
    }
    namespace Windows.System.Profile {
      public enum SystemOutOfBoxExperienceState
      public static class SystemSetupInfo
      public static class WindowsIntegrityPolicy
    }
    namespace Windows.System.Profile.SystemManufacturers {
      public sealed class SystemSupportDeviceInfo
      public static class SystemSupportInfo {
        public static SystemSupportDeviceInfo LocalDeviceInfo { get; }
      }
    }
    namespace Windows.System.RemoteSystems {
      public sealed class RemoteSystem {
        IVectorView<RemoteSystemApp> Apps { get; }
      }
      public sealed class RemoteSystemApp
      public sealed class RemoteSystemAppRegistration
      public sealed class RemoteSystemConnectionInfo
      public sealed class RemoteSystemConnectionRequest {
        RemoteSystemApp RemoteSystemApp { get; }
        public static RemoteSystemConnectionRequest CreateForApp(RemoteSystemApp remoteSystemApp);
      }
      public sealed class RemoteSystemWebAccountFilter : IRemoteSystemFilter
    }
    namespace Windows.System.Update {
      public enum SystemUpdateAttentionRequiredReason
      public sealed class SystemUpdateItem
      public enum SystemUpdateItemState
      public sealed class SystemUpdateLastErrorInfo
      public static class SystemUpdateManager
      public enum SystemUpdateManagerState
      public enum SystemUpdateStartInstallAction
    }
    namespace Windows.System.UserProfile {
      public sealed class AssignedAccessSettings
    }
    namespace Windows.UI.Accessibility {
      public sealed class ScreenReaderPositionChangedEventArgs
      public sealed class ScreenReaderService
    }
    namespace Windows.UI.Composition {
      public enum AnimationPropertyAccessMode
      public sealed class AnimationPropertyInfo : CompositionObject
      public sealed class BooleanKeyFrameAnimation : KeyFrameAnimation
      public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
        void SetExpressionReferenceParameter(string parameterName, IAnimationObject source);
      }
      public enum CompositionBatchTypes : uint {
        AllAnimations = (uint)5,
        InfiniteAnimation = (uint)4,
      }
      public sealed class CompositionGeometricClip : CompositionClip
      public class CompositionGradientBrush : CompositionBrush {
        CompositionMappingMode MappingMode { get; set; }
      }
      public enum CompositionMappingMode
      public class CompositionObject : IAnimationObject, IClosable {
        void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
        public static void StartAnimationGroupWithIAnimationObject(IAnimationObject target, ICompositionAnimationBase animation);
        public static void StartAnimationWithIAnimationObject(IAnimationObject target, string propertyName, CompositionAnimation animation);
      }
      public sealed class Compositor : IClosable {
        BooleanKeyFrameAnimation CreateBooleanKeyFrameAnimation();
        CompositionGeometricClip CreateGeometricClip();
        CompositionGeometricClip CreateGeometricClip(CompositionGeometry geometry);
        RedirectVisual CreateRedirectVisual();
        RedirectVisual CreateRedirectVisual(Visual source);
      }
      public interface IAnimationObject
      public sealed class RedirectVisual : ContainerVisual
    }
    namespace Windows.UI.Composition.Interactions {
      public sealed class InteractionSourceConfiguration : CompositionObject
      public enum InteractionSourceRedirectionMode
      public sealed class InteractionTracker : CompositionObject {
        bool IsInertiaFromImpulse { get; }
        int TryUpdatePosition(Vector3 value, InteractionTrackerClampingOption option);
        int TryUpdatePositionBy(Vector3 amount, InteractionTrackerClampingOption option);
      }
      public enum InteractionTrackerClampingOption
      public sealed class InteractionTrackerInertiaStateEnteredArgs {
        bool IsInertiaFromImpulse { get; }
      }
      public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
        InteractionSourceConfiguration PointerWheelConfig { get; }
      }
    }
    namespace Windows.UI.Input.Inking {
      public enum HandwritingLineHeight
      public sealed class PenAndInkSettings
      public enum PenHandedness
    }
    namespace Windows.UI.Input.Inking.Preview {
      public sealed class PalmRejectionDelayZonePreview : IClosable
    }
    namespace Windows.UI.Notifications {
      public sealed class ScheduledToastNotificationShowingEventArgs
      public sealed class ToastNotifier {
        event TypedEventHandler<ToastNotifier, ScheduledToastNotificationShowingEventArgs> ScheduledToastNotificationShowing;
      }
    }
    namespace Windows.UI.Shell {
      public enum SecurityAppKind
      public sealed class SecurityAppManager
      public struct SecurityAppManagerContract
      public enum SecurityAppState
      public enum SecurityAppSubstatus
      public sealed class TaskbarManager {
        IAsyncOperation<bool> IsSecondaryTilePinnedAsync(string tileId);
        IAsyncOperation<bool> RequestPinSecondaryTileAsync(SecondaryTile secondaryTile);
        IAsyncOperation<bool> TryUnpinSecondaryTileAsync(string tileId);
      }
    }
    namespace Windows.UI.StartScreen {
      public sealed class StartScreenManager {
        IAsyncOperation<bool> ContainsSecondaryTileAsync(string tileId);
        IAsyncOperation<bool> TryRemoveSecondaryTileAsync(string tileId);
      }
    }
    namespace Windows.UI.Text {
      public sealed class RichEditTextDocument : ITextDocument {
        void ClearUndoRedoHistory();
      }
    }
    namespace Windows.UI.Text.Core {
      public sealed class CoreTextLayoutRequest {
        CoreTextLayoutBounds LayoutBoundsVisualPixels { get; }
      }
    }
    namespace Windows.UI.ViewManagement {
      public enum ApplicationViewWindowingMode {
        CompactOverlay = 3,
        Maximized = 4,
      }
    }
    namespace Windows.UI.ViewManagement.Core {
      public sealed class CoreInputView {
        bool TryHide();
        bool TryShow();
        bool TryShow(CoreInputViewKind type);
      }
      public enum CoreInputViewKind
    }
    namespace Windows.UI.WebUI {
      public sealed class BackgroundActivatedEventArgs : IBackgroundActivatedEventArgs
      public delegate void BackgroundActivatedEventHandler(object sender, IBackgroundActivatedEventArgs eventArgs);
      public sealed class NewWebUIViewCreatedEventArgs
      public static class WebUIApplication {
        public static event BackgroundActivatedEventHandler BackgroundActivated;
        public static event EventHandler<NewWebUIViewCreatedEventArgs> NewWebUIViewCreated;
      }
      public sealed class WebUIView : IWebViewControl, IWebViewControl2
    }
    namespace Windows.UI.Xaml {
      public class BrushTransition
      public class ColorPaletteResources : ResourceDictionary
      public class DataTemplate : FrameworkTemplate, IElementFactory {
        UIElement GetElement(ElementFactoryGetArgs args);
        void RecycleElement(ElementFactoryRecycleArgs args);
      }
      public sealed class DebugSettings {
        bool FailFastOnErrors { get; set; }
      }
      public sealed class EffectiveViewportChangedEventArgs
      public class ElementFactoryGetArgs
      public class ElementFactoryRecycleArgs
      public class FrameworkElement : UIElement {
        bool IsLoaded { get; }
        event TypedEventHandler<FrameworkElement, EffectiveViewportChangedEventArgs> EffectiveViewportChanged;
        void InvalidateViewport();
      }
      public interface IElementFactory
      public class ScalarTransition
      public class UIElement : DependencyObject, IAnimationObject {
        bool CanBeScrollAnchor { get; set; }
        public static DependencyProperty CanBeScrollAnchorProperty { get; }
        Vector3 CenterPoint { get; set; }
        ScalarTransition OpacityTransition { get; set; }
        float Rotation { get; set; }
        Vector3 RotationAxis { get; set; }
        ScalarTransition RotationTransition { get; set; }
        Vector3 Scale { get; set; }
        Vector3Transition ScaleTransition { get; set; }
        Shadow Shadow { get; set; }
        public static DependencyProperty ShadowProperty { get; }
        Matrix4x4 TransformMatrix { get; set; }
        Vector3 Translation { get; set; }
        Vector3Transition TranslationTransition { get; set; }
        void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
        virtual void PopulatePropertyInfoOverride(string propertyName, AnimationPropertyInfo animationPropertyInfo);
        void StartAnimation(ICompositionAnimationBase animation);
        void StopAnimation(ICompositionAnimationBase animation);
      }
     public class UIElementWeakCollection : IIterable<UIElement>, IVector<UIElement>
      public class Vector3Transition
      public enum Vector3TransitionComponents : uint
    }
    namespace Windows.UI.Xaml.Automation {
      public sealed class AutomationElementIdentifiers {
        public static AutomationProperty IsDialogProperty { get; }
      }
      public sealed class AutomationProperties {
        public static DependencyProperty IsDialogProperty { get; }
        public static bool GetIsDialog(DependencyObject element);
        public static void SetIsDialog(DependencyObject element, bool value);
      }
    }
    namespace Windows.UI.Xaml.Automation.Peers {
      public class AppBarButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider {
        ExpandCollapseState ExpandCollapseState { get; }
        void Collapse();
        void Expand();
      }
      public class AutomationPeer : DependencyObject {
        bool IsDialog();
        virtual bool IsDialogCore();
      }
      public class MenuBarAutomationPeer : FrameworkElementAutomationPeer
      public class MenuBarItemAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
    }
    namespace Windows.UI.Xaml.Controls {
      public sealed class AnchorRequestedEventArgs
      public class AppBarElementContainer : ContentControl, ICommandBarElement, ICommandBarElement2
      public sealed class AutoSuggestBox : ItemsControl {
        object Description { get; set; }
        public static DependencyProperty DescriptionProperty { get; }
      }
      public enum BackgroundSizing
      public sealed class Border : FrameworkElement {
        BackgroundSizing BackgroundSizing { get; set; }
        public static DependencyProperty BackgroundSizingProperty { get; }
        BrushTransition BackgroundTransition { get; set; }
      }
      public class CalendarDatePicker : Control {
        object Description { get; set; }
        public static DependencyProperty DescriptionProperty { get; }
      }
      public class ComboBox : Selector {
        object Description { get; set; }
        public static DependencyProperty DescriptionProperty { get; }
        bool IsEditable { get; set; }
        public static DependencyProperty IsEditableProperty { get; }
        string Text { get; set; }
        Style TextBoxStyle { get; set; }
        public static DependencyProperty TextBoxStyleProperty { get; }
        public static DependencyProperty TextProperty { get; }
        event TypedEventHandler<ComboBox, ComboBoxTextSubmittedEventArgs> TextSubmitted;
      }
      public sealed class ComboBoxTextSubmittedEventArgs
      public class CommandBarFlyout : FlyoutBase
      public class ContentPresenter : FrameworkElement {
        BackgroundSizing BackgroundSizing { get; set; }
        public static DependencyProperty BackgroundSizingProperty { get; }
        BrushTransition BackgroundTransition { get; set; }
      }
      public class Control : FrameworkElement {
        BackgroundSizing BackgroundSizing { get; set; }
        public static DependencyProperty BackgroundSizingProperty { get; }
        CornerRadius CornerRadius { get; set; }
        public static DependencyProperty CornerRadiusProperty { get; }
      }
      public class DataTemplateSelector : IElementFactory {
        UIElement GetElement(ElementFactoryGetArgs args);
        void RecycleElement(ElementFactoryRecycleArgs args);
      }
      public class DatePicker : Control {
        IReference<DateTime> SelectedDate { get; set; }
        public static DependencyProperty SelectedDateProperty { get; }
        event TypedEventHandler<DatePicker, DatePickerSelectedValueChangedEventArgs> SelectedDateChanged;
      }
      public sealed class DatePickerSelectedValueChangedEventArgs
      public class DropDownButton : Button
      public class DropDownButtonAutomationPeer : ButtonAutomationPeer, IExpandCollapseProvider
      public class Frame : ContentControl, INavigate {
        bool IsNavigationStackEnabled { get; set; }
        public static DependencyProperty IsNavigationStackEnabledProperty { get; }
        bool NavigateToType(TypeName sourcePageType, object parameter, FrameNavigationOptions navigationOptions);
      }
      public class Grid : Panel {
        BackgroundSizing BackgroundSizing { get; set; }
        public static DependencyProperty BackgroundSizingProperty { get; }
      }
      public class IconSourceElement : IconElement
      public sealed class InputPropertyAttribute : Attribute
      public interface IScrollAnchorProvider
      public class MenuBar : Control
      public class MenuBarItem : Control
      public class MenuBarItemFlyout : MenuFlyout
      public class NavigationView : ContentControl {
        UIElement ContentOverlay { get; set; }
        public static DependencyProperty ContentOverlayProperty { get; }
        bool IsPaneVisible { get; set; }
        public static DependencyProperty IsPaneVisibleProperty { get; }
        NavigationViewOverflowLabelMode OverflowLabelMode { get; set; }
        public static DependencyProperty OverflowLabelModeProperty { get; }
        UIElement PaneCustomContent { get; set; }
        public static DependencyProperty PaneCustomContentProperty { get; }
        NavigationViewPaneDisplayMode PaneDisplayMode { get; set; }
        public static DependencyProperty PaneDisplayModeProperty { get; }
        UIElement PaneHeader { get; set; }
        public static DependencyProperty PaneHeaderProperty { get; }
        NavigationViewSelectionFollowsFocus SelectionFollowsFocus { get; set; }
        public static DependencyProperty SelectionFollowsFocusProperty { get; }
        NavigationViewShoulderNavigationEnabled ShoulderNavigationEnabled { get; set; }
        public static DependencyProperty ShoulderNavigationEnabledProperty { get; }
        NavigationViewTemplateSettings TemplateSettings { get; }
        public static DependencyProperty TemplateSettingsProperty { get; }
      }
      public class NavigationViewItem : NavigationViewItemBase {
        bool SelectsOnInvoked { get; set; }
        public static DependencyProperty SelectsOnInvokedProperty { get; }
      }
      public sealed class NavigationViewItemInvokedEventArgs {
        NavigationViewItemBase InvokedItemContainer { get; }
        NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
      }
      public enum NavigationViewOverflowLabelMode
      public enum NavigationViewPaneDisplayMode
      public sealed class NavigationViewSelectionChangedEventArgs {
        NavigationTransitionInfo RecommendedNavigationTransitionInfo { get; }
        NavigationViewItemBase SelectedItemContainer { get; }
      }
      public enum NavigationViewSelectionFollowsFocus
      public enum NavigationViewShoulderNavigationEnabled
      public class NavigationViewTemplateSettings : DependencyObject
      public class Panel : FrameworkElement {
        BrushTransition BackgroundTransition { get; set; }
      }
      public sealed class PasswordBox : Control {
        bool CanPasteClipboardContent { get; }
        public static DependencyProperty CanPasteClipboardContentProperty { get; }
        object Description { get; set; }
        public static DependencyProperty DescriptionProperty { get; }
        FlyoutBase SelectionFlyout { get; set; }
        public static DependencyProperty SelectionFlyoutProperty { get; }
        void PasteFromClipboard();
      }
      public class RelativePanel : Panel {
        BackgroundSizing BackgroundSizing { get; set; }
        public static DependencyProperty BackgroundSizingProperty { get; }
      }
      public class RichEditBox : Control {
        object Description { get; set; }
        public static DependencyProperty DescriptionProperty { get; }
        FlyoutBase ProofingMenuFlyout { get; }
        public static DependencyProperty ProofingMenuFlyoutProperty { get; }
        FlyoutBase SelectionFlyout { get; set; }
        public static DependencyProperty SelectionFlyoutProperty { get; }
        RichEditTextDocument TextDocument { get; }
        event TypedEventHandler<RichEditBox, RichEditBoxSelectionChangingEventArgs> SelectionChanging;
      }
      public sealed class RichEditBoxSelectionChangingEventArgs
      public sealed class RichTextBlock : FrameworkElement {
        FlyoutBase SelectionFlyout { get; set; }
        public static DependencyProperty SelectionFlyoutProperty { get; }
        void CopySelectionToClipboard();
      }
      public sealed class ScrollContentPresenter : ContentPresenter {
        bool CanContentRenderOutsideBounds { get; set; }
        public static DependencyProperty CanContentRenderOutsideBoundsProperty { get; }
        bool SizesContentToTemplatedParent { get; set; }
        public static DependencyProperty SizesContentToTemplatedParentProperty { get; }
      }
      public sealed class ScrollViewer : ContentControl, IScrollAnchorProvider {
        bool CanContentRenderOutsideBounds { get; set; }
        public static DependencyProperty CanContentRenderOutsideBoundsProperty { get; }
        UIElement CurrentAnchor { get; }
        double HorizontalAnchorRatio { get; set; }
        public static DependencyProperty HorizontalAnchorRatioProperty { get; }
        bool ReduceViewportForCoreInputViewOcclusions { get; set; }
        public static DependencyProperty ReduceViewportForCoreInputViewOcclusionsProperty { get; }
        double VerticalAnchorRatio { get; set; }
        public static DependencyProperty VerticalAnchorRatioProperty { get; }
        event TypedEventHandler<ScrollViewer, AnchorRequestedEventArgs> AnchorRequested;
        public static bool GetCanContentRenderOutsideBounds(DependencyObject element);
        void RegisterAnchorCandidate(UIElement element);
        public static void SetCanContentRenderOutsideBounds(DependencyObject element, bool canContentRenderOutsideBounds);
        void UnregisterAnchorCandidate(UIElement element);
      }
      public class SplitButton : ContentControl
      public class SplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IInvokeProvider
      public sealed class SplitButtonClickEventArgs
      public class StackPanel : Panel, IInsertionPanel, IScrollSnapPointsInfo {
        BackgroundSizing BackgroundSizing { get; set; }
        public static DependencyProperty BackgroundSizingProperty { get; }
      }
      public sealed class TextBlock : FrameworkElement {
        FlyoutBase SelectionFlyout { get; set; }
        public static DependencyProperty SelectionFlyoutProperty { get; }
        void CopySelectionToClipboard();
      }
      public class TextBox : Control {
        bool CanPasteClipboardContent { get; }
        public static DependencyProperty CanPasteClipboardContentProperty { get; }
        bool CanRedo { get; }
        public static DependencyProperty CanRedoProperty { get; }
        bool CanUndo { get; }
        public static DependencyProperty CanUndoProperty { get; }
        object Description { get; set; }
        public static DependencyProperty DescriptionProperty { get; }
        FlyoutBase ProofingMenuFlyout { get; }
        public static DependencyProperty ProofingMenuFlyoutProperty { get; }
        FlyoutBase SelectionFlyout { get; set; }
        public static DependencyProperty SelectionFlyoutProperty { get; }
        event TypedEventHandler<TextBox, TextBoxSelectionChangingEventArgs> SelectionChanging;
        void ClearUndoRedoHistory();
        void CopySelectionToClipboard();
        void CutSelectionToClipboard();
        void PasteFromClipboard();
        void Redo();
        void Undo();
      }
      public sealed class TextBoxSelectionChangingEventArgs
      public class TextCommandBarFlyout : CommandBarFlyout
      public class TimePicker : Control {
        IReference<TimeSpan> SelectedTime { get; set; }
        public static DependencyProperty SelectedTimeProperty { get; }
        event TypedEventHandler<TimePicker, TimePickerSelectedValueChangedEventArgs> SelectedTimeChanged;
      }
      public sealed class TimePickerSelectedValueChangedEventArgs
      public class ToggleSplitButton : SplitButton
      public class ToggleSplitButtonAutomationPeer : FrameworkElementAutomationPeer, IExpandCollapseProvider, IToggleProvider
      public sealed class ToggleSplitButtonIsCheckedChangedEventArgs
      public class ToolTip : ContentControl {
        IReference<Rect> PlacementRect { get; set; }
        public static DependencyProperty PlacementRectProperty { get; }
      }
      public class TreeView : Control {
        bool CanDragItems { get; set; }
        public static DependencyProperty CanDragItemsProperty { get; }
        bool CanReorderItems { get; set; }
        public static DependencyProperty CanReorderItemsProperty { get; }
        Style ItemContainerStyle { get; set; }
        public static DependencyProperty ItemContainerStyleProperty { get; }
        StyleSelector ItemContainerStyleSelector { get; set; }
        public static DependencyProperty ItemContainerStyleSelectorProperty { get; }
        TransitionCollection ItemContainerTransitions { get; set; }
        public static DependencyProperty ItemContainerTransitionsProperty { get; }
        object ItemsSource { get; set; }
        public static DependencyProperty ItemsSourceProperty { get; }
        DataTemplate ItemTemplate { get; set; }
        public static DependencyProperty ItemTemplateProperty { get; }
        DataTemplateSelector ItemTemplateSelector { get; set; }
        public static DependencyProperty ItemTemplateSelectorProperty { get; }
        event TypedEventHandler<TreeView, TreeViewDragItemsCompletedEventArgs> DragItemsCompleted;
        event TypedEventHandler<TreeView, TreeViewDragItemsStartingEventArgs> DragItemsStarting;
        DependencyObject ContainerFromItem(object item);
        DependencyObject ContainerFromNode(TreeViewNode node);
        object ItemFromContainer(DependencyObject container);
        TreeViewNode NodeFromContainer(DependencyObject container);
      }
      public sealed class TreeViewCollapsedEventArgs {
        object Item { get; }
      }
      public sealed class TreeViewDragItemsCompletedEventArgs
      public sealed class TreeViewDragItemsStartingEventArgs
      public sealed class TreeViewExpandingEventArgs {
        object Item { get; }
      }
      public class TreeViewItem : ListViewItem {
        bool HasUnrealizedChildren { get; set; }
        public static DependencyProperty HasUnrealizedChildrenProperty { get; }
        object ItemsSource { get; set; }
        public static DependencyProperty ItemsSourceProperty { get; }
      }
      public class TwoPaneView : Control
      public enum TwoPaneViewMode
      public enum TwoPaneViewPriority
      public enum TwoPaneViewTallModeConfiguration
      public enum TwoPaneViewWideModeConfiguration
      public sealed class WebView : FrameworkElement {
        event TypedEventHandler<WebView, WebViewWebResourceRequestedEventArgs> WebResourceRequested;
      }
      public sealed class WebViewWebResourceRequestedEventArgs
    }
    namespace Windows.UI.Xaml.Controls.Maps {
      public enum MapTileAnimationState
      public sealed class MapTileBitmapRequestedEventArgs {
        int FrameIndex { get; }
      }
      public class MapTileSource : DependencyObject {
        MapTileAnimationState AnimationState { get; }
        public static DependencyProperty AnimationStateProperty { get; }
        bool AutoPlay { get; set; }
        public static DependencyProperty AutoPlayProperty { get; }
        int FrameCount { get; set; }
        public static DependencyProperty FrameCountProperty { get; }
        TimeSpan FrameDuration { get; set; }
        public static DependencyProperty FrameDurationProperty { get; }
        void Pause();
        void Play();
        void Stop();
      }
      public sealed class MapTileUriRequestedEventArgs {
        int FrameIndex { get; }
      }
    }
    namespace Windows.UI.Xaml.Controls.Primitives {
      public class CommandBarFlyoutCommandBar : CommandBar
      public sealed class CommandBarFlyoutCommandBarTemplateSettings : DependencyObject
      public class FlyoutBase : DependencyObject {
        bool AreOpenCloseAnimationsEnabled { get; set; }
        public static DependencyProperty AreOpenCloseAnimationsEnabledProperty { get; }
        bool InputDevicePrefersPrimaryCommands { get; }
        public static DependencyProperty InputDevicePrefersPrimaryCommandsProperty { get; }
        bool IsOpen { get; }
        public static DependencyProperty IsOpenProperty { get; }
        FlyoutShowMode ShowMode { get; set; }
        public static DependencyProperty ShowModeProperty { get; }
        public static DependencyProperty TargetProperty { get; }
        void ShowAt(DependencyObject placementTarget, FlyoutShowOptions showOptions);
      }
      public enum FlyoutPlacementMode {
        Auto = 13,
        BottomEdgeAlignedLeft = 7,
        BottomEdgeAlignedRight = 8,
        LeftEdgeAlignedBottom = 10,
        LeftEdgeAlignedTop = 9,
        RightEdgeAlignedBottom = 12,
        RightEdgeAlignedTop = 11,
        TopEdgeAlignedLeft = 5,
        TopEdgeAlignedRight = 6,
      }
      public enum FlyoutShowMode
      public class FlyoutShowOptions
      public class NavigationViewItemPresenter : ContentControl
    }
    namespace Windows.UI.Xaml.Core.Direct {
      public interface IXamlDirectObject
      public sealed class XamlDirect
      public struct XamlDirectContract
      public enum XamlEventIndex
      public enum XamlPropertyIndex
      public enum XamlTypeIndex
    }
    namespace Windows.UI.Xaml.Hosting {
      public class DesktopWindowXamlSource : IClosable
      public sealed class DesktopWindowXamlSourceGotFocusEventArgs
      public sealed class DesktopWindowXamlSourceTakeFocusRequestedEventArgs
      public sealed class WindowsXamlManager : IClosable
      public enum XamlSourceFocusNavigationReason
      public sealed class XamlSourceFocusNavigationRequest
      public sealed class XamlSourceFocusNavigationResult
    }
    namespace Windows.UI.Xaml.Input {
      public sealed class CanExecuteRequestedEventArgs
      public sealed class ExecuteRequestedEventArgs
      public sealed class FocusManager {
        public static event EventHandler<GettingFocusEventArgs> GettingFocus;
        public static event EventHandler<FocusManagerGotFocusEventArgs> GotFocus;
        public static event EventHandler<LosingFocusEventArgs> LosingFocus;
        public static event EventHandler<FocusManagerLostFocusEventArgs> LostFocus;
      }
      public sealed class FocusManagerGotFocusEventArgs
      public sealed class FocusManagerLostFocusEventArgs
      public sealed class GettingFocusEventArgs : RoutedEventArgs {
        Guid CorrelationId { get; }
      }
      public sealed class LosingFocusEventArgs : RoutedEventArgs {
        Guid CorrelationId { get; }
      }
      public class StandardUICommand : XamlUICommand
      public enum StandardUICommandKind
      public class XamlUICommand : DependencyObject, ICommand
    }
    namespace Windows.UI.Xaml.Markup {
      public sealed class FullXamlMetadataProviderAttribute : Attribute
      public interface IXamlBindScopeDiagnostics
      public interface IXamlType2 : IXamlType
    }
    namespace Windows.UI.Xaml.Media {
      public class Brush : DependencyObject, IAnimationObject {
        void PopulatePropertyInfo(string propertyName, AnimationPropertyInfo propertyInfo);
        virtual void PopulatePropertyInfoOverride(string propertyName, AnimationPropertyInfo animationPropertyInfo);
      }
      public class Shadow : DependencyObject
      public class ThemeShadow : Shadow
    }
    namespace Windows.UI.Xaml.Media.Animation {
      public class BasicConnectedAnimationConfiguration : ConnectedAnimationConfiguration
      public sealed class ConnectedAnimation {
        ConnectedAnimationConfiguration Configuration { get; set; }
      }
      public class ConnectedAnimationConfiguration
      public class DirectConnectedAnimationConfiguration : ConnectedAnimationConfiguration
      public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration
      public enum SlideNavigationTransitionEffect
      public sealed class SlideNavigationTransitionInfo : NavigationTransitionInfo {
        SlideNavigationTransitionEffect Effect { get; set; }
        public static DependencyProperty EffectProperty { get; }
      }
    }
    namespace Windows.UI.Xaml.Navigation {
      public class FrameNavigationOptions
    }
    namespace Windows.Web.UI {
      public interface IWebViewControl2
      public sealed class WebViewControlNewWindowRequestedEventArgs {
        IWebViewControl NewWindow { get; set; }
        Deferral GetDeferral();
      }
      public enum WebViewControlPermissionType {
        ImmersiveView = 6,
      }
    }
    namespace Windows.Web.UI.Interop {
      public sealed class WebViewControl : IWebViewControl, IWebViewControl2 {
        event TypedEventHandler<WebViewControl, object> GotFocus;
        event TypedEventHandler<WebViewControl, object> LostFocus;
        void AddInitializeScript(string script);
      }
    }  
    
    

    Removals:

    namespace Windows.Gaming.UI {
      public sealed class GameMonitor
      public enum GameMonitoringPermission
    }
    
    

    The post Windows 10 SDK Preview Build 17723 available now! appeared first on Windows Developer Blog.

    One click deploy for MakeCode and the amazing AdaFruit Circuit Playground Express

    $
    0
    0

    Circuit Playground Express and CrickitThere's a ton of great open source hardware solutions out there. Often they're used to teach kids how to code, but their also fun for adults to learn about hardware!

    Ultimately that "LED Moment" can be the start of a love affair with open source hardware and software! Arduino is great, as is Arduino talking to the Cloud! If that's too much or too many moving parts, you always start small with other little robot kits for kids.

    Recently my 10 year old and I have been playing with the Circuit Playground Express from Adafruit. We like it because it supports not just block-based programming and JavaScript via MakeCode (more on that in a moment) but you can also graduate to Circuit Python. Want to be even more advanced/ You can also use the Arduino IDE to talk to Circuit Playground Express. It's quickly becoming our favorite board. Be sure to get the board, some batteries and a holder, as well as a few alligator clips.

    The Circuit Playground Express board is round and has alligator-clip pads around it so you don't have to solder to get started. It has as bunch of sensors for light, temperature, motion, sound, as well as an IR receiver and transmitter and LEDs for visual output. There's a million things you can do with it. This summer Microsoft Research is doing a project a week you can do with the kids in your life with Make Code!

    I think the Circuit Playground Express is excellent by itself, but I like that I can stack it on top of the AdaFruit Crickit to make a VERY capable robotics platform. It's an ingenious design where three screws and metal standoffs connect the Crickit to the Circuit Playground and provide a bus for power and communication. The 10 year old wants to make a BattleBot now.

    Sitting architecturally on top of all this great hardware is the open source Microsoft Make Code development environment. It's amazing and more people should be talking about it. MakeCode works with LEGO Mindstorms EV3, micro:bit, Circuit Playground Express, Minecraft, Cue robots, Chibichips, and more. The pair of devices is truly awesome.

    Frankly I'm blown away at how easy it is and how easily my kids were productive. The hardest part of the whole thing was the last step where they need to copy the compiled code to the Circuit Playground Express. The editor is all online at GitHub https://github.com/Microsoft/pxt and you can run it locally if you like but there's no reason to unless you're developing new packages.

    We went to https://makecode.adafruit.com/ for the Circuit Playground Express. We made a new project (and optionally added the Crickit board blocks as an extension) and then got to work. The 10 year old followed a tutorial and made a moisture sensor that uses an alligator clip and a nail to check if our plants need to be watered! (If they do, it beeps and turns red!)

    You can see the code here as blocks...

    The MakeCode IDE

    or see the same code as JavaScript!

    let Soil_reading = 0
    let dry_value = 0
    dry_value = 1500
    light.setBrightness(45)
    light.setAll(0x00ff00)
    forever(function () {
        Soil_reading = input.pinA1.value()
        console.logValue("Soil reading", Soil_reading)
        if (Soil_reading < dry_value) {
            light.setAll(0xff0000)
            music.playTone(262, music.beat(BeatFraction.Half))
        } else {
            light.clear()
        }
        pause(__internal.__timePicker(2000))
    })
    

    When you've written your code, you just click DOWNLOAD and you'll get a "uf2" file.

    Downloading compiled MakeCode UF2 files

    Then the hardest part, you plug in the Circuit Playground Express via USB, it shows up as a Drive called "CPLAYBOOT," and you copy that file over. It's easy for techies, but a speed bump for kids.

    Downloading compiled MakeCode UF2 files

    It's really a genius process where they have removed nearly every obstacle in the hardware. After the file gets copied over (literally after the last byte is written) the device resets and starts running it.

    The "Developer's Inner Loop" is as short as possible, so kudos to the team. Code, download, deploy, run/test, repeat.

    This loop is fast and clever, but I wanted to speed it up a little so I wrote this little utility to automatically copy your MakeCode file to the Circuit Playground Express. Basically the idea is:

    • Associate my app with *.uf2 files
    • When launched, look for a local drive labeled CPLAYBOOK and copy the uf2 file over to it.

    That's it. It speeds up the experience and saves me a number of clicks. Sure there's batch file/powershell/script ways to do it but this wasn't hard.

    static void Main(string[] args)
    {
        var sourceFile = args[0];
        var drive = (from d in DriveInfo.GetDrives()
                     where d.VolumeLabel == "CPLAYBOOT"
                     select d.RootDirectory).FirstOrDefault();
        
        if (drive == null) {
            Console.WriteLine("Press RESET on your Circuit Playground Express and try again!");
            Environment.Exit(1);
        }
        Console.WriteLine($"Found Circuit Playground Express at {drive.FullName}");
        File.Copy(sourceFile, Path.Combine(drive.FullName, Path.GetFileName(sourceFile)));
    }
    

    Then I double click on the uf2 file and get this dialog and SCROLL DOWN and click "Look for another app on this PC." (They are making this hard because they want you to use a Store App, which I haven't made yet)

    Selecting a custom app for UF2 files

    Now I can just click my uf2 files in Windows Explorer and they'll automatically get deployed to my Circuit Playground Express!

    Found Circuit Playground Express at D:

    You can find source here https://github.com/shanselman/MakeCodeLaunchAndCopy if you're a developer, just get .NET Core 2.1 and run my .cmd file on Windows to build it yourself. Feel free to make it a Windows Store App if you're an overachiever. Pull Requests appreciated ;)

    Otherwise, get the a little release here https://github.com/shanselman/MakeCodeLaunchAndCopy/releases and unzip the contents into its own folder on Windows, go double-click a UF2 file and point Windows to the MakeCodeLaunchAndCopy.exe file and you're all set!


    Sponsor: Preview the latest JetBrains Rider with its built-in spell checking, initial Blazor support, partial C# 7.3 support, enhanced debugger, C# Interactive, and a redesigned Solution Explorer.



    © 2018 Scott Hanselman. All rights reserved.
         

    4 steps to engage employees with new live events in Microsoft 365

    $
    0
    0

    Earlier this month, we announced new intelligent event capabilities in Microsoft 365 that enable anyone to create live and on-demand events for teams and across the organization. Today, we invite you to use the public preview of live events in Microsoft 365 and discover new ways to foster connection and engagement between leaders and employees at every level in your organization.

    More than ever before, employees in the modern workplace seek work environments that unlock creativity, make their lives more productive and fulfilling, and foster a sense of connection with their organization’s mission and purpose.

    A critical first step for your organization to thrive in this new culture of work is to drive alignment of your people around shared purpose and goals. Leaders realize that organizations who do this well have an advantage in attracting and retaining an engaged workforce.

    Here are four ways your organization can enable leaders and employees to connect with new live events in Microsoft 365:

    1—Use live events to kickstart interactive discussions across your organization

    Today, executives at Microsoft—including CEO Satya Nadella—use Microsoft 365 to connect and communicate with employees around the globe. Now, any company or organization with Microsoft 365 can create these moments of high engagement, where people are focused on leaders and their messages and ask questions to clarify or reinforce conversations in the community.

    Using Microsoft Stream, Teams, or Yammer, you can create a live event wherever your audience, team, or community resides. Attendees receive notifications and can participate in real-time, with high-definition video and interactive discussion using web, mobile, or desktop.

    Following an event, it’s easy to make the recording available on an event page, allowing you to watch the event on your own schedule and catch up quickly with powerful AI features that unlock the content of the event recording. The recording is automatically transcribed and detects changes in speakers—making it simple to search for content later.

    For employees who are in different time zones or unable to attend live, the conversation keeps going, so they still feel connected to leaders and peers—helping to overcome geographical or organizational boundaries.

    The event and recordings are powered by Microsoft Stream, the intelligent video service in Office 365.

    Image of a laptop open to display a live event in Microsoft 365.

    2—Foster sustained dialogue in open communities

    Give everyone a voice—before, during, and after a live event in Microsoft 365—with Yammer communities that span functions or the entire organization. Providing a forum for employees to be heard is an important piece of transforming a culture. These communities are where people can come any time to raise ideas, concerns, or questions, and where leaders can reply in an authentic way.

    An active Yammer community builds trust and a sense of connection and belonging. And it provides a forum where employees who might not feel comfortable speaking out during a live event can connect directly with leaders.

    With inline message translation, live events in Microsoft 365 empowers people to express themselves in their own language.

    3—Create an intranet site for leaders to share events, blogs, video, news, and resources

    Communicate at scale as a leader with a continuous, online presence using content, conversation, and video channels within a SharePoint communications site. You can optimize for news distribution and blogs, and deepen engagement with related content, polls and surveys, and readership analytics.

    This is also a great spot to share recorded events for later viewing. Simply create a dedicated page for each event where employees can submit questions and comments in advance. Leaders and organizers can then use this input to craft the messaging and content of the events.

    4—Plan corporate communications and measure impact

    Executive and internal communications may be managed by a team of one or a team of many—but it takes careful planning and execution to ensure success. Microsoft Teams—the hub for teamwork in Office 365—is ideally suited to work together in the creation and production of events and other executive communications. It provides an effective backstage for your live event, giving you a shared space to work with speakers and approve content before sharing with a broader audience.

    Once you have begun engaging your audience, every message within a Yammer community has a visible count of how many people your post has reached. This helps both community organizers and employees understand what is being read. Group insights demonstrate how the knowledge and information created in the community benefit people—regardless of their membership status in the group. For example, passive visitors may gain value from group conversations and apply the information elsewhere in their daily work. You can also see the number of views for an event recording and across a channel, and how many people liked the video. Pages and news articles also have statistics to understand readership.

    Empowering all leaders across an organization

    Leadership, of course, does not just refer to organizational leaders. Leaders of communities may be subject matter experts, functional managers, or passionate individuals who are leading areas of expertise, practices, or interest groups. These same capabilities in Microsoft 365 can enable leaders at any level to create and sustain connection with their communities.

    Patrick Yates, manager of Diversity and Inclusion at TDS Telecom, considers community connections and engagement an important part of the employee experience, and a boon to recruiting talent. “Younger generations entering the workforce especially want a modern, inclusive environment—to be part of something that’s larger than themselves.”

    Connect your employees and leaders today

    Experience the public preview of live events in Microsoft 365, and get started on connecting your leaders and employees today. We will be adding additional features and functionality based on your feedback in the Tech Community.

    To create a live event, you will need an Office 365 E3 or E5 license and your admin must give you permission to do so. To attend a live event, you need an Office 365 license for authenticated users. Public (anonymous) access is possible in specific configurations.

    To learn more, visit Connect leaders and employees on Office.com, and for more information on the intelligent event capabilities, visit Microsoft live events Tech Community.

    The post 4 steps to engage employees with new live events in Microsoft 365 appeared first on Microsoft 365 Blog.

    Bing Maps Autosuggest API GA Release

    $
    0
    0

    Introducing the Bing Maps Autosuggest API, the newest addition to the Bing Maps REST services. The Autosuggest API is used to return a ranked list of suggested entities based on a user's partial query. The service can return three possible entity types: Addresses (including roads), points of interest, and businesses (currently available in the US only with new markets coming soon).

    A maximum of ten (10) autosuggested entities can be returned per request, and the returned entities can be delimited by country and culture. The response can be specified for either JSON or XML format.

    The Autosuggest API is designed to help developers populate online query forms such as delivery addresses as well as map search bars. Check out this e-commerce online ordering form to see an example of how the Autosuggest API can be used in JavaScript to populate a list of suggested addresses. Another great example of an Autosuggest API usecase is LinkedIn’s “Your Commute” feature. Moreover, autosuggested entities can easily be displayed using the Bing Maps V8 SDK. For an example using JavaScript, the Bing Maps V8 SDK, and Bootstrap, see the Autosuggest API Browser.

    Autosuggest API

    Check out Bing Maps Autosuggest API and let us know what you think. You can connect with the team at the Bing Maps Forums to share feedback and let us know what you would like to see next.

    - Bing Maps Team

    Viewing all 5971 articles
    Browse latest View live


    <script src="https://jsc.adskeeper.com/r/s/rssing.com.1596347.js" async> </script>