Updates to the Lenovo ThinkPad L390 and L390 Yoga are designed to keep users and IT departments happy through proven reliability and comprehensive device security—without sacrificing performance.
The post The Lenovo ThinkPad L390 and L390 Yoga are ready for business, whatever the size appeared first on Microsoft 365 Blog.
There is a new Azure PowerShell module that is built to harness the power of PowerShell Core and Cloud Shell and maintain compatibility with Windows PowerShell 5.1. Its name is “Az.” Az ensures that Windows PowerShell and PowerShell Core users can get the latest Azure tooling in every PowerShell on every platform. Az also simplifies and normalizes Azure PowerShell cmdlet and module names. Az ships in Azure Cloud Shell and is available from the PowerShell Gallery.
The Az module version 1.0 was released on December 18, 2018, and will be updated on a two-week cadence in 2019, starting with a January 15, 2019 release.
As with all Azure PowerShell modules, Az uses semantic versioning and implements a strict breaking change policy – all breaking changes require advance customer notice and can only occur during breaking change releases.
For complete details on the release, timeline, and compatibility features, check out the Az announcement page.
You can find complete details on the Az roadmap and features on the Az announcement page.
Users are not required to migrate from AzureRM, as AzureRM will continue to be supported. However, it is important to note that all new Azure PowerShell features will appear only in ‘Az’. Az has new features to ease migration, and these are discussed in depth in the Az 1.0 Migration Guide. If you have scripts written for AzureRM, there are three paths for migration
The Az module is cross-platform, and so some authentication mechanisms supported by Connect-AzureRmAccount have been changed or removed in the Az 1.0 version of the Connect-AzAccount cmdlet, as they are not supported on all platforms. Some of these authentication mechanisms will be enabled in future versions:
Interactive login with automatic web page login display will be enabled for Windows PowerShell 5.1 only in the January 15, 2019 release and will be supported across all platforms in early 2019.
The Az module can run in Windows PowerShell 5.1, but requires .NET Framework version 4.7.2 or later. Azure Automation cloud workers currently support .NET Framework version 4.6.1. Azure Automation is updating their cloud workers to support .NET version 4.7.2, and until these new workers are deployed, Az cannot be used in Azure Automation cloud runbooks.
The Azure Automation team plans to deploy cloud workers supporting .NET 4.7.2 to all Azure environments and regions by March 15, 2019. You should expect to see more announcements as this rollout progresses in the new year. You can find more information on the Az announcement page.
Az, which is open source, shipped version 1.0 on December 18, 2018. You can install Az from the PowerShell Gallery and if you want to go through the code then you can check the Azure PowerShell GitHub repository.
We would like to invite you to install and try the new, cross-platform Az module and we look forward to hearing your questions, comments, or issues with Az either by using the built-in Send-Feedback cmdlet, or via GitHub by submitting an issue.
We are excited to share the auto-protection capability for SQL Server in Azure Virtual Machines (VM). This is a key addition to the public preview of Azure Backup for SQL Server on Azure VM, announced earlier this year. Azure Backup for SQL Server is an enterprise credible, zero-infrastructure pay as you go (PAYG) service that leverages native SQL backup and restore APIs to provide a comprehensive solution to backup SQL servers running in Azure VMs.
What happens when you add a new database to your protected SQL Server? You need to rediscover the database and then manually trigger configure protection to backup that database. Now imagine if we take away the work from you and automatically detect and protect each new database you add to the instance. Our new auto-protection feature does just that.
Auto-protection is a capability that lets you automatically protect all the databases in a standalone SQL Server instance or a SQL Server Always On availability group. Not only does it enable backups for the existing databases, but it also protects all the databases that you may add in future.
You can enable auto-protection for the desired SQL Server instance or Always On availability group under Configure Backup for SQL Server in Azure VM. When enabled, all the databases for that SQL Server will automatically be selected. You can then define the backup policy for the selected databases. After you associate the policy, you can see the newly protected databases under the Backup items.
Thus, if there is a significant addition or deletion of databases in your environment, auto-protection capability will save you time and effort by automatically discovering and protecting the new databases.
by Hong Ooi, senior data scientist, Microsoft Azure
A few weeks ago, I introduced the AzureR family of packages for working with Azure in R. Since then, I’ve also written articles on how to use AzureRMR to interact with Azure Resource Manager, how to use AzureVM to manage virtual machines, and how to use AzureContainers to deploy R functions with Azure Kubernetes Service. This article is the next in the series, and covers AzureStor: an interface to Azure storage.
AzureStor implements an interface to Azure Resource Manager, which you can use manage storage accounts: creating them, retrieving them, deleting them, and so forth. This is done via the appropriate methods of the az_resource_group class. For example, the following code shows how you might create a new storage account from scratch.
library(AzureStor)
# get the resource group for the storage account
rg <- AzureRMR::az_rm$
new(tenant="{tenant_id}", app="{app_id}", password="{password}")$
get_subscription("{subscription_id}")$
get_resource_group("myresourcegroup")
# create the storage account
# by default, this will be in the resource group's region
rg$create_storage_account("mynewstorage")Without any options, this will create a storage account with the following parameters:
You can change these by setting the arguments to create_storage_account(). For example, to create an account with geo-redundant storage replication and the default blob access tier set to “cool”:
rg$create_storage_account("myotherstorage",
replication="Standard_GRS",
access_tier="cool")To retrieve an existing storage account, use the get_storage_account() method. Only the storage account name is required.
# retrieve one of the accounts created above
stor2 <- rg$get_storage_account("myotherstorage")Finally, to delete a storage account, you simply call its delete() method. Alternatively, you can call the delete_storage_account() method of the az_resource_group class, which will do the same thing. In both cases, AzureStor will prompt you for confirmation that you really want to delete the storage account.
rg$delete_storage_account("mynewstorage")
stor2$delete() # if you have the storage account objectPerhaps the more relevant part of AzureStor for most users is its client interface to storage. With this, you can upload and download files and blobs, create containers and shares, list files, and so on. Unlike the ARM interface, the client interface uses S3 classes. This is for a couple of reasons: it is more familiar to most R users, and it is consistent with most other data manipulation packages in R, in particular the tidyverse.
The starting point for client access is the storage_endpoint object, which stores information about the endpoint of a storage account: the URL that you use to access storage, along with any authentication information needed. The easiest way to obtain an endpoint object is via the storage account resource object’s get_blob_endpoint() and get_file_endpoint() methods:
# get the storage account object
stor <- AzureRMR::az_rm$
new(tenant="{tenant_id}", app="{app_id}", password="{password}")$
get_subscription("{subscription_id}")$
get_resource_group("myresourcegroup")$
get_storage_account("mynewstorage")
stor$get_blob_endpoint()
# Azure blob storage endpoint
# URL: https://mynewstorage.blob.core.windows.net/
# Access key: <hidden>
# Account shared access signature: <none supplied>
# Storage API version: 2018-03-28
stor$get_file_endpoint()
# Azure file storage endpoint
# URL: https://mynewstorage.file.core.windows.net/
# Access key: <hidden>
# Account shared access signature: <none supplied>
# Storage API version: 2018-03-28This shows that the base URL to access blob storage is https://mynewstorage.blob.core.windows.net/, while that for file storage is https://mynewstorage.file.core.windows.net/. While it’s not displayed, the endpoint objects also include the access key necessary for authenticated access to storage; this is obtained directly from the storage account resource.
More practically, you will usually want to work with a storage endpoint without having to go through the process of authenticating with Azure Resource Manager (ARM). Often, you may not have any ARM credentials to start with. In this case, you can create the endpoint object directly with blob_endpoint() and file_endpoint():
# same as above
blob_endp <- blob_endpoint(
"https://mynewstorage.blob.core.windows.net/",
key="mystorageaccesskey")
file_endp <- file_endpoint(
"https://mynewstorage.file.core.windows.net/",
key="mystorageaccesskey")Notice that when creating the endpoint this way, you have to provide the access key explicitly.
Instead of an access key, you can provide a shared access signature (SAS) to gain authenticated access. The main difference between using a key and a SAS is that the former unlocks access to the entire storage account. A user who has a key can access all containers and files, and can read, modify and delete data without restriction. On the other hand, a user with a SAS can be limited to have access only to specific files, or be limited to read access, or only for a given span of time, and so on. This is usually much better in terms of security.
Usually, the SAS will be given to you by your system administrator. However, if you have the storage acccount resource object, you can generate and use a SAS as follows. Note that generating a SAS requires the storage account’s access key.
# shared access signature: read/write access, container+object access, valid for 12 hours
now <- Sys.time()
sas <- stor$get_account_sas(permissions="rw",
resource_types="co",
start=now,
end=now + 12 * 60 * 60,
key=stor$list_keys()[1])
# create an endpoint object with a SAS, but without an access key
blob_endp <- stor$get_blob_endpoint(sas=sas)If you don’t have a key or a SAS, you will only have access to unauthenticated (public) containers and file shares.
Given an endpoint object, AzureStor provides the following methods for working with containers:
blob_container: get an existing blob containercreate_blob_container: create a new blob containerdelete_blob_container: delete a blob containerlist_blob_containers: return a list of blob container objectsfile_share: get an existing file sharecreate_file_share: create a new file sharedelete_file_share: delete a file sharelist_file_shares: return a list of file share objectsHere is some example blob container code showing their use. The file share code is similar.
# an existing container
cont <- blob_container(blob_endp, "mycontainer")
# create a new container and allow
# unauthenticated (public) access to blobs
newcont <- create_blob_container(blob_endp, "mynewcontainer",
public_access="blob")
# delete the container
delete_blob_container(newcont)
# piping also works
library(magrittr)
blob_endp %>%
blob_container("mycontainer")As a convenience, instead of providing an endpoint object and a container name, you can also provide the full URL to the container. If you do this, you’ll also have to supply any necessary authentication details such as the access key or SAS.
cont <- blob_container(
"https://mynewstorage.blob.core.windows.net/mycontainer",
key="mystorageaccountkey")
share <- file_share(
"https://mynewstorage.file.core.windows.net/myshare",
key="mystorageaccountkey")Given a blob container or file share object, use the list_blobs() and list_azure_files() functions to list the storage objects they contain. The “azure” in list_azure_files is to avoid any confusion with R’s regular list.files function.
# list blobs inside a blob container
list_blobs(cont)
# Name Last-Modified Content-Length
# 1 fs.txt 2018-10-13 11:34:30 132
# 2 fs2.txt 2018-10-13 11:04:36 731930
# if you want only the filenames
list_blobs(cont, info="name")
# [1] "fs.txt" "fs2.txt"
# and for files inside a file share
list_azure_files(share, "/")
# name type size
# 1 100k.txt File 100000
# 2 fs.txt File 132To transfer files and blobs, use the following functions:
upload_blob/download_blob: transfer a file to or from a blob container.upload_azure_file/download_azure_file: transfer a file to or from a file share.upload_to_url: upload a file to a destination given by a URL. This dispatches to either upload_blob or upload_azure_file as appropriate.download_from_url: download a file from a source given by a URL, the opposite of upload_from_url. This is analogous to base R’s download.file but with authentication built in.# upload a file to a blob container
blob_endp <- blob_endpoint(
"https://mynewstorage.blob.core.windows.net/",
key="mystorageaccesskey")
cont <- blob_container(blob_endp, "mycontainer")
upload_blob(cont, src="myfile", dest="myblob")
# again, piping works
blob_endpoint(
"https://mynewstorage.blob.core.windows.net/",
key="mystorageaccesskey") %>%
blob_container("mycontainer") %>%
upload_blob("myfile", "myblob")
# download a blob, overwriting any existing destination file
download_blob(cont, "myblob", "myfile", overwrite=TRUE)
# as a convenience, you can download directly from an Azure URL
download_from_url(
"https://mynewstorage.blob.core.windows.net/mycontainer/myblob",
"myfile",
key="mystorageaccesskey",
overwrite=TRUE)File shares have the additional feature of supporting directories. To create and delete directories, use create_azure_dir() and delete_azure_dir():
list_azure_files(share, "/")
# name type size
# 1 100k.txt File 100000
# 2 fs.txt File 132
# create a directory under the root of the file share
create_azure_dir(share, "newdir")
# confirm that the directory has been created
list_azure_files(share, "/")
# name type size
# 1 100k.txt File 100000
# 2 fs.txt File 132
# 3 newdir Directory NA
# delete the directory
delete_azure_dir(share, "newdir")The AzureStor package is available now on Github.
The Bing Maps team is happy to announce Bing Maps Local Insights API. With the release of Bing Maps Local Search API earlier this month, we are excited to include another API to the collection.
Bing Maps Local Insights API is powerful REST API that provides insights into business and entities within a given area that can be reached by driving, walking or public transit within a given time or distance. Local Insights can help score the attractiveness of a location based on the proximity to points of interest, making it easy for you to determine how close you are to things that are important to you. For example, find out how many restaurants, bars, movie theaters, parks or other kinds of places are nearby and also take into consideration the predicted traffic at the time that matters most to you.
Other use cases can include a variety of real estate and commercial scenarios. e.g. you can profile neighborhoods (e.g., Restaurants, schools within walking distances etc.) to help house hunters identify the perfect neighborhood for a new home. Also, you can display a list of businesses such as gas stations nearby that could be helpful when planning for a new business location.
Local Insights can enable the following visualization scenarios on a map:
What makes the API so powerful, is that you can call it in a number of different ways such as:
Here is a sampe API call that gets a list of Local Insights that are Movie Theaters or Departments Stores within a 30-minute drive of the Redmond Microsoft Campus.
http://dev.virtualearth.net/REST/V1/Routes/LocalInsights?Waypoint=1%20Microsoft%20Way,Redmond,WA&TravelMode=Driving&Optimize=time&MaxTime=30&TimeUnit=Minute&cats=DepartmentStores,MovieTheaters&key={BingMapsAPIKey}The example JSON output below shows that there are 20 department stores within a 30-minute driving time. The JSON response provides the names of the department stores and movie theaters along with the latitude/longitude for those locations so that they can be displayed on a map and/or the results can be aggregated for summary purposes. The JSON response also includes the geocode (latitude/longitude) for the Waypoint location (i.e., 1 Microsoft Way, Redmond, WA) that was submitted in the query.
{
"authenticationResultCode": "ValidCredentials",
"brandLogoUri": "http://dev.virtualearth.net/Branding/logo_powered_by.png",
"copyright": "Copyright © 2018 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.",
"resourceSets": [
{
"estimatedTotal": 1,
"resources": [
{
"__type": "LocalInsightsResponse:http://schemas.microsoft.com/search/local/ws/rest/v1",
"typeResults": [
{
"typeName": "Department Stores",
"typeSummary": "20 Department Stores in 30 Minutes by Driving",
"entities": [
{
"entityName": "Sears Stores",
"latitude": 47.630211,
"longitude": -122.141318
},
{
"entityName": "Fred Meyer",
"latitude": 47.62886852137511,
"longitude": -122.14475288604169
},
{
"entityName": "Daiso Japan",
"latitude": 47.620109,
"longitude": -122.130684
},
{
"entityName": "Ben Franklin Crafts",
"latitude": 47.6745642853546,
"longitude": -122.129096602237
},
{
"entityName": "HomeGoods",
"latitude": 47.61322,
"longitude": -122.18475
},
{
"entityName": "Costco Wholesale",
"latitude": 47.68118,
"longitude": -122.1815
},
{
"entityName": "Costco Wholesale Kirkland Warehouse",
"latitude": 47.68073998682604,
"longitude": -122.18175410738384
},
{
"entityName": "Revolve Consignment",
"latitude": 47.53507,
"longitude": -122.03667
},
{
"entityName": "Shoprite",
"latitude": 47.6224741119901,
"longitude": -122.312563286076
},
{
"entityName": "Daiso",
"latitude": 47.59634,
"longitude": -122.32614
},
{
"entityName": "Zara",
"latitude": 47.61188,
"longitude": -122.33729
},
{
"entityName": "Bargain Plaza",
"latitude": 47.50071935713182,
"longitude": -122.17796977901406
},
{
"entityName": "Fjallraven",
"latitude": 47.628875696097,
"longitude": -122.358053052728
},
{
"entityName": "Rama Deli and Market",
"latitude": 47.61655,
"longitude": -122.35243
},
{
"entityName": "USA Laptops Sreens Inc",
"latitude": 47.72458,
"longitude": -122.34086
},
{
"entityName": "Westfield Southcenter Mall",
"latitude": 47.458834,
"longitude": -122.258126
},
{
"entityName": "Westfield Southcenter",
"latitude": 47.45813,
"longitude": -122.25599
},
{
"entityName": "Quilts Etc",
"latitude": 47.45813,
"longitude": -122.25599
},
{
"entityName": "India Plaza",
"latitude": 47.46574,
"longitude": -122.28955
},
{
"entityName": "Eddie Bauer",
"latitude": 47.490105,
"longitude": -121.796338
}
]
},
{
"typeName": "Movie Theaters",
"typeSummary": "2 Movie Theaters in 30 Minutes by Driving",
"entities": [
{
"entityName": "SecondStory Repertory",
"latitude": 47.66998,
"longitude": -122.11959
},
{
"entityName": "AMC Kent Station 14",
"latitude": 47.384842653844814,
"longitude": -122.23544404894568
}
]
}
],
"origin": {
"latitude": 47.640068,
"longitude": -122.129858
}
}
]
}
],
"statusCode": 200,
"statusDescription": "OK",
"traceId": "40b9d0d37c344ce99e75a80d62e5112a|DAPZHU-DEV|7.7.0.0|Ref A: 814E90439D604CA5A5995AA54709F5EC Ref B: CO1EDGE0420 Ref C: 2018-10-15T21:44:55Z"
}
To get started with the API, check out the documentation:
https://docs.microsoft.com/en-us/bingmaps/rest-services/routes/local-insights
https://docs.microsoft.com/en-us/bingmaps/rest-services/routes/local-insights-data
As always, we can’t wait to see what you build with the new API. To learn more about Bing Maps APIs and how to get licensed, go to https://www.microsoft.com/maps.
- Bing Maps Team
The Bing Maps team is happy to announce Bing Maps Local Insights API. With the release of Bing Maps Local Search API earlier this month, we are excited to include another API to the collection.
Bing Maps Local Insights API is powerful REST API that provides insights into business and entities within a given area that can be reached by driving, walking or public transit within a given time or distance. Local Insights can help score the attractiveness of a location based on the proximity to points of interest, making it easy for you to determine how close you are to things that are important to you. For example, find out how many restaurants, bars, movie theaters, parks or other kinds of places are nearby and also take into consideration the predicted traffic at the time that matters most to you.
Other use cases can include a variety of real estate and commercial scenarios. e.g. you can profile neighborhoods (e.g., Restaurants, schools within walking distances etc.) to help house hunters identify the perfect neighborhood for a new home. Also, you can display a list of businesses such as gas stations nearby that could be helpful when planning for a new business location.
Local Insights can enable the following visualization scenarios on a map:
What makes the API so powerful, is that you can call it in a number of different ways such as:
Here is a sampe API call that gets a list of Local Insights that are Movie Theaters or Departments Stores within a 30-minute drive of the Redmond Microsoft Campus.
http://dev.virtualearth.net/REST/V1/Routes/LocalInsights?Waypoint=1%20Microsoft%20Way,Redmond,WA&TravelMode=Driving&Optimize=time&MaxTime=30&TimeUnit=Minute&cats=DepartmentStores,MovieTheaters&key={BingMapsAPIKey}The example JSON output below shows that there are 20 department stores within a 30-minute driving time. The JSON response provides the names of the department stores and movie theaters along with the latitude/longitude for those locations so that they can be displayed on a map and/or the results can be aggregated for summary purposes. The JSON response also includes the geocode (latitude/longitude) for the Waypoint location (i.e., 1 Microsoft Way, Redmond, WA) that was submitted in the query.
{
"authenticationResultCode": "ValidCredentials",
"brandLogoUri": "http://dev.virtualearth.net/Branding/logo_powered_by.png",
"copyright": "Copyright © 2018 Microsoft and its suppliers. All rights reserved. This API cannot be accessed and the content and any results may not be used, reproduced or transmitted in any manner without express written permission from Microsoft Corporation.",
"resourceSets": [
{
"estimatedTotal": 1,
"resources": [
{
"__type": "LocalInsightsResponse:http://schemas.microsoft.com/search/local/ws/rest/v1",
"typeResults": [
{
"typeName": "Department Stores",
"typeSummary": "20 Department Stores in 30 Minutes by Driving",
"entities": [
{
"entityName": "Sears Stores",
"latitude": 47.630211,
"longitude": -122.141318
},
{
"entityName": "Fred Meyer",
"latitude": 47.62886852137511,
"longitude": -122.14475288604169
},
{
"entityName": "Daiso Japan",
"latitude": 47.620109,
"longitude": -122.130684
},
{
"entityName": "Ben Franklin Crafts",
"latitude": 47.6745642853546,
"longitude": -122.129096602237
},
{
"entityName": "HomeGoods",
"latitude": 47.61322,
"longitude": -122.18475
},
{
"entityName": "Costco Wholesale",
"latitude": 47.68118,
"longitude": -122.1815
},
{
"entityName": "Costco Wholesale Kirkland Warehouse",
"latitude": 47.68073998682604,
"longitude": -122.18175410738384
},
{
"entityName": "Revolve Consignment",
"latitude": 47.53507,
"longitude": -122.03667
},
{
"entityName": "Shoprite",
"latitude": 47.6224741119901,
"longitude": -122.312563286076
},
{
"entityName": "Daiso",
"latitude": 47.59634,
"longitude": -122.32614
},
{
"entityName": "Zara",
"latitude": 47.61188,
"longitude": -122.33729
},
{
"entityName": "Bargain Plaza",
"latitude": 47.50071935713182,
"longitude": -122.17796977901406
},
{
"entityName": "Fjallraven",
"latitude": 47.628875696097,
"longitude": -122.358053052728
},
{
"entityName": "Rama Deli and Market",
"latitude": 47.61655,
"longitude": -122.35243
},
{
"entityName": "USA Laptops Sreens Inc",
"latitude": 47.72458,
"longitude": -122.34086
},
{
"entityName": "Westfield Southcenter Mall",
"latitude": 47.458834,
"longitude": -122.258126
},
{
"entityName": "Westfield Southcenter",
"latitude": 47.45813,
"longitude": -122.25599
},
{
"entityName": "Quilts Etc",
"latitude": 47.45813,
"longitude": -122.25599
},
{
"entityName": "India Plaza",
"latitude": 47.46574,
"longitude": -122.28955
},
{
"entityName": "Eddie Bauer",
"latitude": 47.490105,
"longitude": -121.796338
}
]
},
{
"typeName": "Movie Theaters",
"typeSummary": "2 Movie Theaters in 30 Minutes by Driving",
"entities": [
{
"entityName": "SecondStory Repertory",
"latitude": 47.66998,
"longitude": -122.11959
},
{
"entityName": "AMC Kent Station 14",
"latitude": 47.384842653844814,
"longitude": -122.23544404894568
}
]
}
],
"origin": {
"latitude": 47.640068,
"longitude": -122.129858
}
}
]
}
],
"statusCode": 200,
"statusDescription": "OK",
"traceId": "40b9d0d37c344ce99e75a80d62e5112a|DAPZHU-DEV|7.7.0.0|Ref A: 814E90439D604CA5A5995AA54709F5EC Ref B: CO1EDGE0420 Ref C: 2018-10-15T21:44:55Z"
}
To get started with the API, check out the documentation:
https://docs.microsoft.com/en-us/bingmaps/rest-services/routes/local-insights
https://docs.microsoft.com/en-us/bingmaps/rest-services/routes/local-insights-data
As always, we can’t wait to see what you build with the new API. To learn more about Bing Maps APIs and how to get licensed, go to https://www.microsoft.com/maps.
- Bing Maps Team
The Belgian Federal Police chose Microsoft 365 E3 to support their workplace modernization journey. A unified Microsoft cloud platform delivers strategic value for a police organization because it creates a sustainable, agile, and highly secure workplace culture. As they take a leadership role in their journey to the cloud, they’re using Microsoft 365 tools to improve collaboration—and help solve crimes in the process.
The post Belgian police move into the digital age nationwide, solve crimes faster with Microsoft 365 appeared first on Microsoft 365 Blog.
The Belgian Federal Police chose Microsoft 365 E3 to support their workplace modernization journey. A unified Microsoft cloud platform delivers strategic value for a police organization because it creates a sustainable, agile, and highly secure workplace culture. As they take a leadership role in their journey to the cloud, they’re using Microsoft 365 tools to improve collaboration—and help solve crimes in the process.
The post Belgian police move into the digital age nationwide, solve crimes faster with Microsoft 365 appeared first on Microsoft 365 Blog.
Visual Studio 2019 Preview 1 introduces an improved debugger for C++ that uses an external 64-bit process for hosting its memory-intensive components. If you’ve experienced memory-related issues while debugging C++ applications before, these issues should now be largely resolved with Visual Studio 2019.
One of the areas of feedback for the debugger in Visual Studio has been around its high memory usage during debugging of large and complex C++ applications. Most of the memory consumption in this scenario is due to the large amounts of symbol information that the debugger needs to load to show program data in the debugger windows. Memory usage tends to increase over the course of a debugging session as the debugger stops in different parts of the application and encounters new symbols that need to be loaded. Eventually the Visual Studio process might crash due to running out of memory.
We’ve made significant optimizations in Visual Studio 2017 to mitigate this problem. For example, the 15.6 update introduced memory optimizations to /Debug:fastlink, which resulted in a 30% reduction in the debugger’s memory consumption. As we look to further avoid this issue in Visual Studio 2019, we have moved memory-intensive components to a separate 64-bit process.
We closely worked with internal and external partner teams to ensure the changes we were making to the debugger were validated on large native real-world applications. The following video shows a side-by-side comparison of the memory usage between Visual Studio 2017 and Visual Studio 2019 while debugging of Gears of War 4 developed by The Coalition. Visual Studio 2017 memory usage climbs up to 1.3 GB after a few minutes of stepping through the game code and inspecting variables. Visual Studio 2019 gives far better memory usage in the same scenario: its memory usage stays flat around 285 MB as the symbol data is kept in the debugger’s 64-bit worker process.
We’ve also tested the runtime performance and ensured there is no noticeable overhead due to calls between components that are now going over a process boundary.
Here are the unsupported scenarios and known issues with the updated debugger:
If you need to continue using the debugger in-process due to the known issues mentioned above, you can turn it off by going to the Debugging tab in Tools -> Options and unchecking the option “Load debug symbols in external process (native only)”.
Download Visual Studio 2019 Preview 1 today, and start using the improved debugger on your large native applications. If you run into any issues with it (e.g. stability, performance, incompatible extensions or EE add-ins) or if you have a suggestion for us, please let us know via the ‘Send Feedback’ button in the top right corner of Visual Studio or via Developer Community.
This blog was co-authored by Sumeet Mittal, Senior Program Manager, Azure Networking.
Earlier this year in July, we announced the public preview for Virtual Network Service Endpoints and Firewall rules for both Azure Event Hubs and Azure Service Bus. Today, we’re excited to announce that we are making these capabilities generally available to our customers.
This feature adds to the security and control Azure customers have over their cloud environments. Now, traffic from your virtual network to your Azure Service Bus Premium namespaces and Standard and Dedicated Azure Event Hubs namespaces can be kept secure from public Internet access and completely private on the Azure backbone network.
Virtual Network Service Endpoints do this by extending your virtual network private address space and the identity of your virtual network to your virtual networks. Customers dealing with PII (Financial Services, Insurance, etc.) or looking to further secure access to their cloud visible resources will benefit the most from this feature. For more details on the finer workings of Virtual Network service endpoints, refer to the documentation.
Firewall rules further allow a specific IP address or a specified range of IP addresses to access the resources.
Virtual Network Service Endpoints and Firewall rules are supported for the tiers listed below for all public regions at no extra cost.
| Service | Tier |
| Azure Service Bus | Premium tier |
| Azure Event Hubs | Standard and Dedicated tier |
Azure Event Hubs, a highly reliable and easily scalable data streaming service, and Azure Service Bus, which provides enterprise messaging, are the new set of serverless offerings joining the growing list of Azure services that have enabled Virtual Network Service Endpoints.
To get more details on these features, please visit the documentation links below:
For step by step guidance on how to integrate Virtual Networks service endpoints and set up Firewalls (IP Filtering), check out the tutorial, “Enable Virtual Networks Integration and Firewalls on Event Hubs namespace.”
Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 18298 or greater). The Preview SDK Build 18298 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.
In this Preview SDK, we’ll be adding a blend mode to the effect graph of the AcrylicBrush called Luminosity. This blend mode will ensure that shadows do not appear behind acrylic surfaces without a cutout. We will also be exposing a LuminosityBlendOpacity API available for tweaking that allows for more AcrylicBrush customization.
By default, for those that have not specified any LuminosityBlendOpacity on their AcrylicBrushes, we have implemented some logic to ensure that the Acrylic will look as similar as it can to current 1809 acrylics. Please note that we will be updating our default brushes to account for this recipe change.
Events generated by TraceLoggingProvider.h (e.g. via TraceLoggingWrite macros) will now always have Id and Version set to 0.
Previously, TraceLoggingProvider.h would assign IDs to events at link time. These IDs were unique within a DLL or EXE, but changed from build to build and from module to module.
namespace Windows.AI.MachineLearning {
public sealed class LearningModelSession : IClosable {
public LearningModelSession(LearningModel model, LearningModelDevice deviceToRunOn, LearningModelSessionOptions learningModelSessionOptions);
}
public sealed class LearningModelSessionOptions
public sealed class TensorBoolean : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorBoolean CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorBoolean CreateFromShapeArrayAndDataArray(long[] shape, bool[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorDouble : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorDouble CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorDouble CreateFromShapeArrayAndDataArray(long[] shape, double[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorFloat : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorFloat CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorFloat CreateFromShapeArrayAndDataArray(long[] shape, float[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorFloat16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorFloat16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorFloat16Bit CreateFromShapeArrayAndDataArray(long[] shape, float[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt16Bit CreateFromShapeArrayAndDataArray(long[] shape, short[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt32Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt32Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt32Bit CreateFromShapeArrayAndDataArray(long[] shape, int[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt64Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt64Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt64Bit CreateFromShapeArrayAndDataArray(long[] shape, long[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorInt8Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorInt8Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorInt8Bit CreateFromShapeArrayAndDataArray(long[] shape, byte[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorString : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorString CreateFromShapeArrayAndDataArray(long[] shape, string[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt16Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt16Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt16Bit CreateFromShapeArrayAndDataArray(long[] shape, ushort[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt32Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt32Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt32Bit CreateFromShapeArrayAndDataArray(long[] shape, uint[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt64Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt64Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt64Bit CreateFromShapeArrayAndDataArray(long[] shape, ulong[] data);
IMemoryBufferReference CreateReference();
}
public sealed class TensorUInt8Bit : IClosable, ILearningModelFeatureValue, IMemoryBuffer, ITensor {
void Close();
public static TensorUInt8Bit CreateFromBuffer(long[] shape, IBuffer buffer);
public static TensorUInt8Bit CreateFromShapeArrayAndDataArray(long[] shape, byte[] data);
IMemoryBufferReference CreateReference();
}
}
namespace Windows.ApplicationModel {
public sealed class Package {
StorageFolder EffectiveLocation { get; }
StorageFolder MutableLocation { get; }
}
}
namespace Windows.ApplicationModel.AppService {
public sealed class AppServiceConnection : IClosable {
public static IAsyncOperation<StatelessAppServiceResponse> SendStatelessMessageAsync(AppServiceConnection connection, RemoteSystemConnectionRequest connectionRequest, ValueSet message);
}
public sealed class AppServiceTriggerDetails {
string CallerRemoteConnectionToken { get; }
}
public sealed class StatelessAppServiceResponse
public enum StatelessAppServiceResponseStatus
}
namespace Windows.ApplicationModel.Calls {
public sealed class PhoneLine {
string TransportDeviceId { get; }
void EnableTextReply(bool value);
}
public enum PhoneLineTransport {
Bluetooth = 2,
}
public sealed class PhoneLineTransportDevice
}
namespace Windows.ApplicationModel.Calls.Background {
public enum PhoneIncomingCallDismissedReason
public sealed class PhoneIncomingCallDismissedTriggerDetails
public enum PhoneTriggerType {
IncomingCallDismissed = 6,
}
}
namespace Windows.ApplicationModel.Calls.Provider {
public static class PhoneCallOriginManager {
public static bool IsSupported { get; }
}
}
namespace Windows.ApplicationModel.ConversationalAgent {
public sealed class ConversationalAgentSessionInterruptedEventArgs
public enum ConversationalAgentSessionUpdateResponse
public sealed class ConversationalAgentSignalDetectedEventArgs
}
namespace Windows.ApplicationModel.Resources {
public sealed class ResourceLoader {
public static ResourceLoader GetForUIContext(UIContext context);
}
}
namespace Windows.ApplicationModel.Resources.Core {
public sealed class ResourceCandidate {
ResourceCandidateKind Kind { get; }
}
public enum ResourceCandidateKind
public sealed class ResourceContext {
public static ResourceContext GetForUIContext(UIContext context);
}
}
namespace Windows.Devices.Enumeration {
public enum DevicePairingKinds : uint {
ProvidePasswordCredential = (uint)16,
}
public sealed class DevicePairingRequestedEventArgs {
void AcceptWithPasswordCredential(PasswordCredential passwordCredential);
}
}
namespace Windows.Devices.Input {
public sealed class PenDevice
public sealed class SpatialGazeDevice
}
namespace Windows.Devices.PointOfService {
public sealed class JournalPrinterCapabilities : ICommonPosPrintStationCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class JournalPrintJob : IPosPrinterJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
}
public sealed class PaymentDevice : IClosable
public sealed class PaymentDeviceCapabilities
public sealed class PaymentDeviceConfiguration
public sealed class PaymentDeviceGetConfigurationResult
public sealed class PaymentDeviceOperationResult
public sealed class PaymentDeviceTransactionRequest
public sealed class PaymentDeviceTransactionResult
public sealed class PaymentMethod
public enum PaymentMethodKind
public enum PaymentOperationStatus
public enum PaymentUserResponse
public sealed class PosPrinter : IClosable {
IVectorView<uint> SupportedBarcodeSymbologies { get; }
PosPrinterFontProperty GetFontProperty(string typeface);
}
public sealed class PosPrinterFontProperty
public sealed class PosPrinterPrintOptions
public sealed class ReceiptPrinterCapabilities : ICommonPosPrintStationCapabilities, ICommonReceiptSlipCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class ReceiptPrintJob : IPosPrinterJob, IReceiptOrSlipJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
void StampPaper();
}
public struct SizeUInt32
public sealed class SlipPrinterCapabilities : ICommonPosPrintStationCapabilities, ICommonReceiptSlipCapabilities {
bool IsReversePaperFeedByLineSupported { get; }
bool IsReversePaperFeedByMapModeUnitSupported { get; }
bool IsReverseVideoSupported { get; }
bool IsStrikethroughSupported { get; }
bool IsSubscriptSupported { get; }
bool IsSuperscriptSupported { get; }
}
public sealed class SlipPrintJob : IPosPrinterJob, IReceiptOrSlipJob {
void FeedPaperByLine(int lineCount);
void FeedPaperByMapModeUnit(int distance);
void Print(string data, PosPrinterPrintOptions printOptions);
}
}
namespace Windows.Devices.PointOfService.Provider {
public sealed class PaymentDeviceCloseTerminalRequest
public sealed class PaymentDeviceCloseTerminalRequestEventArgs
public sealed class PaymentDeviceConnection : IClosable
public sealed class PaymentDeviceConnectionTriggerDetails
public sealed class PaymentDeviceConnectorInfo
public sealed class PaymentDeviceGetTerminalsRequest
public sealed class PaymentDeviceGetTerminalsRequestEventArgs
public sealed class PaymentDeviceOpenTerminalRequest
public sealed class PaymentDeviceOpenTerminalRequestEventArgs
public sealed class PaymentDevicePaymentAuthorizationRequest
public sealed class PaymentDevicePaymentAuthorizationRequestEventArgs
public sealed class PaymentDevicePaymentRequest
public sealed class PaymentDevicePaymentRequestEventArgs
public sealed class PaymentDeviceReadCapabilitiesRequest
public sealed class PaymentDeviceReadCapabilitiesRequestEventArgs
public sealed class PaymentDeviceReadConfigurationRequest
public sealed class PaymentDeviceReadConfigurationRequestEventArgs
public sealed class PaymentDeviceRefundRequest
public sealed class PaymentDeviceRefundRequestEventArgs
public sealed class PaymentDeviceVoidTokenRequest
public sealed class PaymentDeviceVoidTokenRequestEventArgs
public sealed class PaymentDeviceVoidTransactionRequest
public sealed class PaymentDeviceVoidTransactionRequestEventArgs
public sealed class PaymentDeviceWriteConfigurationRequest
public sealed class PaymentDeviceWriteConfigurationRequestEventArgs
}
namespace Windows.Globalization {
public sealed class CurrencyAmount
}
namespace Windows.Graphics.DirectX {
public enum DirectXPrimitiveTopology
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
HolographicViewConfiguration ViewConfiguration { get; }
}
public sealed class HolographicDisplay {
HolographicViewConfiguration TryGetViewConfiguration(HolographicViewConfigurationKind kind);
}
public sealed class HolographicViewConfiguration
public enum HolographicViewConfigurationKind
}
namespace Windows.Management.Deployment {
public enum AddPackageByAppInstallerOptions : uint {
LimitToExistingPackages = (uint)512,
}
public enum DeploymentOptions : uint {
RetainFilesOnFailure = (uint)2097152,
}
}
namespace Windows.Media.Devices {
public sealed class InfraredTorchControl
public enum InfraredTorchMode
public sealed class VideoDeviceController : IMediaDeviceController {
InfraredTorchControl InfraredTorchControl { get; }
}
}
namespace Windows.Media.Miracast {
public sealed class MiracastReceiver
public sealed class MiracastReceiverApplySettingsResult
public enum MiracastReceiverApplySettingsStatus
public enum MiracastReceiverAuthorizationMethod
public sealed class MiracastReceiverConnection : IClosable
public sealed class MiracastReceiverConnectionCreatedEventArgs
public sealed class MiracastReceiverCursorImageChannel
public sealed class MiracastReceiverCursorImageChannelSettings
public sealed class MiracastReceiverDisconnectedEventArgs
public enum MiracastReceiverDisconnectReason
public sealed class MiracastReceiverGameControllerDevice
public enum MiracastReceiverGameControllerDeviceUsageMode
public sealed class MiracastReceiverInputDevices
public sealed class MiracastReceiverKeyboardDevice
public enum MiracastReceiverListeningStatus
public sealed class MiracastReceiverMediaSourceCreatedEventArgs
public sealed class MiracastReceiverSession : IClosable
public sealed class MiracastReceiverSessionStartResult
public enum MiracastReceiverSessionStartStatus
public sealed class MiracastReceiverSettings
public sealed class MiracastReceiverStatus
public sealed class MiracastReceiverStreamControl
public sealed class MiracastReceiverVideoStreamSettings
public enum MiracastReceiverWiFiStatus
public sealed class MiracastTransmitter
public enum MiracastTransmitterAuthorizationStatus
}
namespace Windows.Networking.Connectivity {
public enum NetworkAuthenticationType {
Wpa3 = 10,
Wpa3Sae = 11,
}
}
namespace Windows.Networking.NetworkOperators {
public sealed class ESim {
ESimDiscoverResult Discover();
ESimDiscoverResult Discover(string serverAddress, string matchingId);
IAsyncOperation<ESimDiscoverResult> DiscoverAsync();
IAsyncOperation<ESimDiscoverResult> DiscoverAsync(string serverAddress, string matchingId);
}
public sealed class ESimDiscoverEvent
public sealed class ESimDiscoverResult
public enum ESimDiscoverResultKind
}
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static event EventHandler<PushNotificationChannelsRevokedEventArgs> ChannelsRevoked;
}
public sealed class PushNotificationChannelsRevokedEventArgs
}
namespace Windows.Perception.People {
public sealed class EyesPose
public enum HandJointIndex
public sealed class HandMesh
public sealed class HandPose
public struct HandVertexPositionAndNormal
public enum JointPoseAccuracy
}
namespace Windows.Perception.Spatial.Preview {
public sealed class SpatialGraphInteropFrameOfReferencePreview
public static class SpatialGraphInteropPreview {
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem);
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem, Vector3 relativePosition);
public static SpatialGraphInteropFrameOfReferencePreview TryCreateFrameOfReference(SpatialCoordinateSystem coordinateSystem, Vector3 relativePosition, Quaternion relativeOrientation);
}
}
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.Storage.Pickers {
public sealed class FileOpenPicker {
User User { get; }
public static FileOpenPicker CreateForUser(User user);
}
public sealed class FileSavePicker {
User User { get; }
public static FileSavePicker CreateForUser(User user);
}
public sealed class FolderPicker {
User User { get; }
public static FolderPicker CreateForUser(User user);
}
}
namespace Windows.System {
public sealed class DispatcherQueue {
bool HasThreadAccess { get; }
}
public enum ProcessorArchitecture {
Arm64 = 12,
X86OnArm64 = 14,
}
}
namespace Windows.System.Profile {
public static class AppApplicability
public sealed class UnsupportedAppRequirement
public enum UnsupportedAppRequirementReasons : uint
}
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
User User { get; }
public static RemoteSystemWatcher CreateWatcherForUser(User user);
public static RemoteSystemWatcher CreateWatcherForUser(User user, IIterable<IRemoteSystemFilter> filters);
}
public sealed class RemoteSystemApp {
string ConnectionToken { get; }
User User { get; }
}
public sealed class RemoteSystemConnectionRequest {
string ConnectionToken { get; }
public static RemoteSystemConnectionRequest CreateFromConnectionToken(string connectionToken);
public static RemoteSystemConnectionRequest CreateFromConnectionTokenForUser(User user, string connectionToken);
}
public sealed class RemoteSystemWatcher {
User User { get; }
}
}
namespace Windows.UI.Composition {
public enum CompositionBitmapInterpolationMode {
MagLinearMinLinearMipLinear = 2,
MagLinearMinLinearMipNearest = 3,
MagLinearMinNearestMipLinear = 4,
MagLinearMinNearestMipNearest = 5,
MagNearestMinLinearMipLinear = 6,
MagNearestMinLinearMipNearest = 7,
MagNearestMinNearestMipLinear = 8,
MagNearestMinNearestMipNearest = 9,
}
public sealed class CompositionGraphicsDevice : CompositionObject {
CompositionMipmapSurface CreateMipmapSurface(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
}
public sealed class CompositionMipmapSurface : CompositionObject, ICompositionSurface
public sealed class CompositionRadialGradientBrush : CompositionGradientBrush
public class CompositionTransform : CompositionObject
public sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
public sealed class Compositor : IClosable {
CompositionRadialGradientBrush CreateRadialGradientBrush();
CompositionVisualSurface CreateVisualSurface();
}
public interface IVisualElement
public sealed class UIContentRoot
public sealed class UIContext
}
namespace Windows.UI.Composition.Interactions {
public enum InteractionBindingAxisModes : uint
public sealed class InteractionTracker : CompositionObject {
public static void SetBindingMode(InteractionTracker boundTracker1, InteractionTracker boundTracker2, InteractionBindingAxisModes axisMode);
}
public sealed class InteractionTrackerCustomAnimationStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerIdleStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerInertiaStateEnteredArgs {
bool IsFromBinding { get; }
}
public sealed class InteractionTrackerInteractingStateEnteredArgs {
bool IsFromBinding { get; }
}
public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
public static VisualInteractionSource CreateFromIVisualElement(IVisualElement source);
}
}
namespace Windows.UI.Composition.Scenes {
public enum SceneAlphaMode
public enum SceneAttributeSemantic
public sealed class SceneBoundingBox : SceneObject
public class SceneComponent : SceneObject
public sealed class SceneComponentCollection : SceneObject, IIterable<SceneComponent>, IVector<SceneComponent>
public enum SceneComponentType
public class SceneMaterial : SceneObject
public class SceneMaterialInput : SceneObject
public sealed class SceneMesh : SceneObject
public sealed class SceneMeshMaterialAttributeMap : SceneObject, IIterable<IKeyValuePair<string, SceneAttributeSemantic>>, IMap<string, SceneAttributeSemantic>
public sealed class SceneMeshRendererComponent : SceneRendererComponent
public sealed class SceneMetallicRoughnessMaterial : ScenePbrMaterial
public sealed class SceneModelTransform : CompositionTransform
public sealed class SceneNode : SceneObject
public sealed class SceneNodeCollection : SceneObject, IIterable<SceneNode>, IVector<SceneNode>
public class SceneObject : CompositionObject
public class ScenePbrMaterial : SceneMaterial
public class SceneRendererComponent : SceneComponent
public sealed class SceneSurfaceMaterialInput : SceneMaterialInput
public sealed class SceneVisual : ContainerVisual
public enum SceneWrappingMode
}
namespace Windows.UI.Core {
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
UIContext UIContext { get; }
}
}
namespace Windows.UI.Core.Preview {
public sealed class CoreAppWindowPreview
}
namespace Windows.UI.Input {
public class AttachableInputObject : IClosable
public sealed class InputActivationListener : AttachableInputObject
public sealed class InputActivationListenerActivationChangedEventArgs
public enum InputActivationState
}
namespace Windows.UI.Input.Preview {
public static class InputActivationListenerPreview
}
namespace Windows.UI.Input.Spatial {
public sealed class SpatialInteractionSource {
bool IsHandMeshSupported { get; }
bool IsHandPoseSupported { get; }
IAsyncOperation<HandMesh> TryGetHandMeshAsync();
}
public sealed class SpatialInteractionSourceState {
HandPose TryGetHandPose();
}
public sealed class SpatialPointerPose {
EyesPose Eyes { get; }
}
}
namespace Windows.UI.Notifications {
public sealed class ToastActivatedEventArgs {
ValueSet UserInput { get; }
}
public sealed class ToastNotification {
bool ExpiresOnReboot { get; set; }
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
ApplicationWindowPresenterKind AppliedPresenterKind { get; }
string PersistedStateName { get; }
UIContext UIContext { get; }
public static IAsyncOperation<bool> ClearAllPersistedStateAsync();
public static IAsyncOperation<bool> ClearPersistedStateAsync(string value);
IVectorView<DisplayRegion> TryGetDisplayRegions();
WindowingEnvironment TryGetWindowingEnvironment();
bool TrySetPersistedStateName(string value);
}
public sealed class InputPane {
public static InputPane GetForUIContext(UIContext context);
}
public sealed class UISettings {
bool AutoHideScrollBars { get; }
event TypedEventHandler<UISettings, UISettingsAutoHideScrollBarsChangedEventArgs> AutoHideScrollBarsChanged;
}
public sealed class UISettingsAutoHideScrollBarsChangedEventArgs
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
public static CoreInputView GetForUIContext(UIContext context);
}
}
namespace Windows.UI.Xaml {
public class UIElement : DependencyObject, IAnimationObject, IVisualElement {
Vector3 ActualOffset { get; }
Vector2 ActualSize { get; }
Shadow Shadow { get; set; }
public static DependencyProperty ShadowProperty { get; }
UIContext UIContext { get; }
XamlRoot XamlRoot { get; set; }
}
public class UIElementWeakCollection : IIterable<UIElement>, IVector<UIElement>
public sealed class Window {
UIContext UIContext { get; }
}
public sealed class XamlRoot
public sealed class XamlRootChangedEventArgs
}
namespace Windows.UI.Xaml.Controls {
public sealed class DatePickerFlyoutPresenter : Control {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class FlyoutPresenter : ContentControl {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class InkToolbar : Control {
InkPresenter TargetInkPresenter { get; set; }
public static DependencyProperty TargetInkPresenterProperty { get; }
}
public class MenuFlyoutPresenter : ItemsControl {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class RichEditBox : Control {
void CopySelectionToClipboard();
void CutSelectionToClipboard();
void PasteFromClipboard();
}
public sealed class TimePickerFlyoutPresenter : Control {
bool IsDefaultShadowEnabled { get; set; }
public static DependencyProperty IsDefaultShadowEnabledProperty { get; }
}
public class TwoPaneView : Control
public enum TwoPaneViewMode
public enum TwoPaneViewPriority
public enum TwoPaneViewTallModeConfiguration
public enum TwoPaneViewWideModeConfiguration
}
namespace Windows.UI.Xaml.Controls.Primitives {
public sealed class AppBarTemplateSettings : DependencyObject {
double NegativeCompactVerticalDelta { get; }
double NegativeHiddenVerticalDelta { get; }
double NegativeMinimalVerticalDelta { get; }
}
public sealed class CommandBarTemplateSettings : DependencyObject {
double OverflowContentCompactYTranslation { get; }
double OverflowContentHiddenYTranslation { get; }
double OverflowContentMinimalYTranslation { get; }
}
public class FlyoutBase : DependencyObject {
bool IsConstrainedToRootBounds { get; }
bool ShouldConstrainToRootBounds { get; set; }
public static DependencyProperty ShouldConstrainToRootBoundsProperty { get; }
XamlRoot XamlRoot { get; set; }
}
public sealed class Popup : FrameworkElement {
bool IsConstrainedToRootBounds { get; }
bool ShouldConstrainToRootBounds { get; set; }
public static DependencyProperty ShouldConstrainToRootBoundsProperty { get; }
}
}
namespace Windows.UI.Xaml.Core.Direct {
public enum XamlPropertyIndex {
AppBarTemplateSettings_NegativeCompactVerticalDelta = 2367,
AppBarTemplateSettings_NegativeHiddenVerticalDelta = 2368,
AppBarTemplateSettings_NegativeMinimalVerticalDelta = 2369,
CommandBarTemplateSettings_OverflowContentCompactYTranslation = 2384,
CommandBarTemplateSettings_OverflowContentHiddenYTranslation = 2385,
CommandBarTemplateSettings_OverflowContentMinimalYTranslation = 2386,
FlyoutBase_ShouldConstrainToRootBounds = 2378,
FlyoutPresenter_IsDefaultShadowEnabled = 2380,
MenuFlyoutPresenter_IsDefaultShadowEnabled = 2381,
Popup_ShouldConstrainToRootBounds = 2379,
UIElement_ActualOffset = 2382,
UIElement_ActualSize = 2383,
}
}
namespace Windows.UI.Xaml.Documents {
public class TextElement : DependencyObject {
XamlRoot XamlRoot { get; set; }
}
}
namespace Windows.UI.Xaml.Hosting {
public class DesktopWindowXamlSource : IClosable {
bool ProcessKeyboardAccelerator(VirtualKey key, VirtualKeyModifiers modifiers);
}
public sealed class ElementCompositionPreview {
public static UIElement GetApplicationWindowContent(AppWindow applicationWindow);
public static void SetApplicationWindowContent(AppWindow applicationWindow, UIElement xamlContent);
}
}
namespace Windows.UI.Xaml.Input {
public sealed class FocusManager {
public static object GetFocusedElement(XamlRoot xamlRoot);
}
public class StandardUICommand : XamlUICommand {
StandardUICommandKind Kind { get; set; }
}
}
namespace Windows.UI.Xaml.Media {
public class AcrylicBrush : XamlCompositionBrushBase {
IReference<double> TintLuminosityOpacity { get; set; }
public static DependencyProperty TintLuminosityOpacityProperty { get; }
}
public class Shadow : DependencyObject
public class ThemeShadow : Shadow
public sealed class VisualTreeHelper {
public static IVectorView<Popup> GetOpenPopupsForXamlRoot(XamlRoot xamlRoot);
}
}
namespace Windows.UI.Xaml.Media.Animation {
public class GravityConnectedAnimationConfiguration : ConnectedAnimationConfiguration {
bool IsShadowEnabled { get; set; }
}
}
namespace Windows.Web.Http {
public sealed class HttpClient : IClosable, IStringable {
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryDeleteAsync(Uri uri);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryGetAsync(Uri uri);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryGetAsync(Uri uri, HttpCompletionOption completionOption);
IAsyncOperationWithProgress<HttpGetBufferResult, HttpProgress> TryGetBufferAsync(Uri uri);
IAsyncOperationWithProgress<HttpGetInputStreamResult, HttpProgress> TryGetInputStreamAsync(Uri uri);
IAsyncOperationWithProgress<HttpGetStringResult, HttpProgress> TryGetStringAsync(Uri uri);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryPostAsync(Uri uri, IHttpContent content);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TryPutAsync(Uri uri, IHttpContent content);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TrySendRequestAsync(HttpRequestMessage request);
IAsyncOperationWithProgress<HttpRequestResult, HttpProgress> TrySendRequestAsync(HttpRequestMessage request, HttpCompletionOption completionOption);
}
public sealed class HttpGetBufferResult : IClosable, IStringable
public sealed class HttpGetInputStreamResult : IClosable, IStringable
public sealed class HttpGetStringResult : IClosable, IStringable
public sealed class HttpRequestResult : IClosable, IStringable
}
The post Windows 10 SDK Preview Build 18298 available now! appeared first on Windows Developer Blog.
We are releasing a new app called Office—a way to help users get started with Office, find what they need, and jump into their work quickly.
The post Introducing the Office app for Windows 10 appeared first on Microsoft 365 Blog.
We are releasing a new app called Office—a way to help users get started with Office, find what they need, and jump into their work quickly.
The post Introducing the Office app for Windows 10 appeared first on Microsoft 365 Blog.
Gartner recently published their analysis of the Enterprise Information Archiving (EIA) market, the Magic Quadrant for Enterprise Information Archiving Tools, and Microsoft has been recognized as a Leader in the Magic Quadrant.
The post Microsoft recognized as a Leader in the Gartner 2018 Enterprise Information Archiving Magic Quadrant appeared first on Microsoft 365 Blog.
Gartner recently published their analysis of the Enterprise Information Archiving (EIA) market, the Magic Quadrant for Enterprise Information Archiving Tools, and Microsoft has been recognized as a Leader in the Magic Quadrant.
The post Microsoft recognized as a Leader in the Gartner 2018 Enterprise Information Archiving Magic Quadrant appeared first on Microsoft 365 Blog.
A monthly roundup of news about Artificial Intelligence, Machine Learning and Data Science. This is an eclectic collection of interesting blog posts, software announcements and data applications from Microsoft and elsewhere that I've noted over the past month or so.
PyTorch 1.0 has been released with faster performance, better support for distributed computing, a new C++ frontend, and a model-sharing repository.
Tensorflow 2.0 will include a built-in implementation of Keras for deeper integration and support of eager execution.
The AI Now Institute has published the AI Now Report 2018, and makes 10 recommendations related to the social impact of AI technology.
Stanford's AI Index 2018 Annual Report documents the year's progress in AI teaching, research, and humanlike capabilities.
Tableau adds SSL support for connecting the R server for its R integration feature.
AWS Lambda adds support for Python 3.7, and offers a customization framework for supporting other programming languages.
New features in Amazon SageMaker: semantic segmentation, early stopping for automatic model tuning, and tools for tracking machine learning experiments.
H20.ai's machine learning platform now available as a hosted service on AWS.
Microsoft calls for government regulation on the use of facial recognition technology.
The Microsoft Connect event on December 4 included several product announcements related to Machine Learning and AI, summarized below.
Azure Machine Learning service is now generally available. This service orchestrates the training and deployment of machine learning modules, using resources managed on-premises or in Azure. Capabilities include:
Azure Notebooks, the hosted Jupyter Notebooks service, has been updated. New features include:
ONNX Runtime, a cross-platform, high-performance engine for inferencing with trained ML models in the Open Neural Network Exchange (ONNX) representation, has been released as open source.
ML.NET 0.8, the open-source machine learning framework for .NET, is now available with new recommendation scenarios and a feature importance tool.
The Language Understanding service can now be deployed in a self-hosted container.
The Translator Text API now offers customized translation to support specialized expressions and vocabulary.
Neural Text to Speech, a preview feature of Cognitive Services Speech Service, synthesizes spoken voices indistinguishable from real people.
Azure Functions now supports serverless deployment of Python functions. This blog post provides detailed examples.
Azure SQL Database now provides integration with the R language (in preview).
AzureR: a new suite of packages to manage Azure services with R.
The book Bayesian Methods for Hackers is now available as a series of Jupyter Notebooks with code in Tensorflow.
A tutorial on causal inference in computing systems, presented by Amit Sharma and Emre Kicima at KDD 2018.
A guide to resources and tutorials for getting started with machine learning on Azure.
A tutorial on packaging Cognitive Services APIs into containers and running them on a Docker-enabled platform.
Pattern Recognition and Machine Learning, the 2006 book by Christopher M Bishop, is now available for free download.
A 4-part series on the history and recent advancements in neural word embeddings.
Using a computer vision model to measure building footprints in satellite images.
Using active learning to track the migration of endangered bird species.
Using deep learning to improve the effectiveness of diabetic retinopathy models.
Using computer vision to quantify fish stocks in Australia.
A collection of reference architectures for deploying machine learning and AI models to real-time applications and batch processes with Azure.
Find previous editions of the monthly AI roundup here.
The Microsoft Devices Team is excited to announce Project Mu, the open-source release of the Unified Extensible Firmware Interface (UEFI) core leveraged by Microsoft products including both Surface and the latest releases of Hyper-V. UEFI is system software that initializes hardware during the boot process and provides services for the operating system to load. Project Mu contributes numerous UEFI features targeted at modern Windows based PCs. It also demonstrates a code structure and development process for efficiently building scalable and serviceable firmware. These enhancements allow Project Mu devices to support Firmware as a Service (FaaS). Similar to Windows as a Service, Firmware as a Service optimizes UEFI and other system firmware for timely quality patches that keep firmware up to date and enables efficient development of post-launch features.
When first enabling FaaS on Surface, we learned that the open source UEFI implementation TianoCore was not optimized for rapid servicing across multiple product lines. We spent several product cycles iterating on FaaS, and have now published the result as free, open source Project Mu! We are hopeful that the ecosystem will incorporate these ideas and code, as well as provide us with ongoing feedback to continue improvements.
We look forward to engagements with the ecosystem as we continue to evolve and improve Project Mu to our mutual benefit!
Check out Project Mu Documentation and Code here: https://microsoft.github.io/mu/
The post Introducing Project Mu appeared first on Windows Developer Blog.
In this post, I’ll cover three free resources every developer needs for learning Azure. Dan Fernandez leads the team responsible for bringing our technical documentation and learning resources into a more modern experience that supports new capabilities that were impossible to deliver via MSDN. Recently, I invited Dan to record a few episodes of Azure Friday with Donovan Brown and spend some time showing off the work his team is doing to provide the best doc and learning experience.
Last December, I wrote 4 tips for learning Azure in the new year, in which I included links to several resources, including the Azure documentation. In that post, I admit that I did a disservice by glossing over the revolution that Microsoft Docs truly represents – both internally and externally. Not only did it radically change how we create documentation, it improved how you can learn and use Azure.
Did you know that the Azure docs are not only open source, but it’s currently the fastest growing project on GitHub? In this episode, Dan shows off some cool features, a few tips & tricks, how you can contribute, and a few buried treasures.
Whether you’re trying to wrap your head around architectural concepts, or you need to get down into the nitty-gritty of understanding a particular API, Dan shows how Azure Docs has you covered.
Unified Microsoft API references:
At Microsoft Ignite 2018, the team working on Microsoft Docs delivered a new approach to learning with Microsoft Learn, which added a new dimension to what's available for those seeking to learn Azure.
Dan gives a quick tour of Microsoft Learn. With Microsoft Learn, you learn-by-doing with interactive, step-by-step tutorials creating real resources in Azure. Even better - it’s free, and no credit card is required.
Microsoft Docs and Microsoft Learn are the bedrock for Azure technical content. Several of our documentation sets are open source, hosted on GitHub. More teams at Microsoft are adopting this model all the time. Even document sets that are not entirely open source have public-facing repos where we invite you to make pull requests. And Microsoft Learn will continue to grow, expanding into new areas and going deeper past the fundamentals to more advanced topics.
The most recent update to The Developer’s Guide to Azure includes cover-to-cover improvements that you shouldn't miss. Written by developers (Michael Crump at Microsoft and Azure MVP Barry Luijbregts) for developers, this guide will show you how to get started with Azure and which services you can use to run your applications, store your data, incorporate intelligence, build IoT apps, and deploy your solutions more efficiently and securely.
On December 18, 2018, the Azure PowerShell team released the first stable version of “Az,” a new cross-platform PowerShell module that will replace AzureRM. You can install this module by running “Install-Module Az” in an elevated PowerShell prompt.
Since January 2018, PowerShell has been a cross-platform product with the introduction of PowerShell Core. Therefore, it has also become a priority for Azure PowerShell to have cross-platform support. Because of the changes required to support running Azure PowerShell cross-platform, we decided to create a new module rather than make modifications to the existing AzureRM module. Moving forward, all new functionality will be added to the Az module, while AzureRM will only be updated with bug fixes.
Because both Az and AzureRM use the same dependencies with different versions, it is not possible to run Az and AzureRM side by side in the same PowerShell session. Thus, Az and AzureRM cmdlets cannot be used together in scripts and in interactive sessions. To ensure that a script does not try to import both Az and AzureRM modules in the same session, if you do not have many existing scripts that use AzureRM, we recommend that you remove all AzureRM modules from your machine after installing Az. For your convenience, we have created the “Uninstall-AzureRm” cmdlet, located in in the new Az module. To use this cmdlet, please ensure that all PowerShell sessions in which AzureRM modules are imported have been closed, then run “Uninstall-AzureRm” in an elevated PowerShell session.
If you would like to continue using AzureRM for your existing scripts while also writing new scripts using Az then you have two possible options.
One option is to install Az on PowerShell Core 6 while continuing to use AzureRM on Windows PowerShell 5.1. This will allow you to run your existing AzureRM scripts on Windows PowerShell 5.1 without the possibility of running into issues where AzureRM and Az are imported in the same session.
Alternatively, if you cannot install PowerShell 6 on your machine, please ensure that you explicitly require either the Az or the AzureRM modules you intend to use at the beginning of each script, making certain that the modules required are not from both AzureRM and Az. To turn off warnings about the side by side installation of AzureRM and Az, please add “$env:SkipAzInstallationChecks=true” to your PowerShell profile.
To simplify and normalize our cmdlet names, we have changed the prefix from AzureRM and Azure to Az for every cmdlet in the new Az modules. To enable preexisting scripts that were written for AzureRM to successfully execute in Az, we have written a cmdlet, “Enable-AzureRmAlias,” to create aliases to the old cmdlet names. This cmdlet includes a Scope parameter, which allows you to select whether the aliases should be created for only the current session or for all future sessions. Additionally, you can import aliases for specific modules using the “Module” parameter. Once your scripts have been converted to use “Az” prefixes, aliases can be turned off using the “Disable-AzureRmAlias” cmdlet. All new cmdlets added to the Az modules will not have these AzureRM aliases, so all new scripts should use the “Az” prefix syntax.
If you are looking for a quick way to test out the new Az modules interactively, CloudShell will now be shipping with the new Az modules. CloudShell is a great option as it runs everywhere and doesn’t require an install so you can keep your environment untouched while trying out all the new Az features. Simply navigate to the PowerShell tab within a CloudShell session, and all Az modules will be automatically installed into your session.
We want the new Az module to enable you to be more productive and efficient in managing Azure from any platform or operating system. Therefore, we would like to invite you to try out the new cross-platform module and we look forward to getting your feedback, suggestions or issues via the built-in “Send-Feedback” cmdlet, which is available in both AzureRM and the new Az module. Alternatively, you can always open an issue in our GitHub repository.
Queries can start with either a table name like “search” or “union *” operators. These commands are useful during data exploration and for searching terms over the entire data model. However, these operators are not efficient for productization in alerts. Log alerts rules queries in Log Analytics and Application Insights should always start with table(s), this is to define a clear scope for the query execution to specific table(s). It also improves both query performance and relevance of the results. You can learn more by visiting our documentation, “Query best practices.”
Note that using cross-resource queries in log alerts rules is not considered inefficient although “union” operator is used. The “union” in cross-resource queries is scoped to specific resources and tables as shown in this example, while the query scope for “union *” is the entire data model.
Union
app('Contoso-app1').requests,
app('Contoso-app2').requests,
workspace('Contoso-workspace1').Perf
After data exploration and query authoring, you may want to create a log alert using that query. These examples show how you can modify queries and avoid “search” and “union *” commands.
You want to create log alert on the following query.
search ObjectName == 'Memory' and (CounterName == '% Committed Bytes In Use' or CounterName == '% Used Memory') and TimeGenerated > ago(5m) | summarize Avg_Memory_Usage =avg(CounterValue) by Computer | where Avg_Memory_Usage between(90 .. 95) | count
To author a valid alert query without the use of “search” operator, follow these steps:
1. Identify the table that the properties are hosted in.
search ObjectName == 'Memory' and (CounterName == '% Committed Bytes In Use' or CounterName == '% Used Memory') | summarize by $table
The result indicates that these properties belong to Perf table.
2. Since the properties used in the query are from Perf table, the query should start with it and scope the query execution to that table.
Perf | where ObjectName == 'Memory' and (CounterName == '% Committed Bytes In Use' or CounterName == '% Used Memory') and TimeGenerated > ago(5m) | summarize Avg_Memory_Usage=avg(CounterValue) by Computer | where Avg_Memory_Usage between(90 .. 95) | count
You want to create log alert on the following query.
search (ObjectName == 'Processor' and CounterName == '% Idle Time' and InstanceName == '_Total') | where Computer !in ((union * | where CounterName == '% Processor Utility' | summarize by Computer)) | summarize Avg_Idle_Time = avg(CounterValue) by Computer, CounterPath | where Avg_Idle_Time < 5 | count
To modify the query, follow these steps:
1. Since the query makes a use of both “search” and “union *” operators, you need to identify the tables hosting the properties in two stages.
search (ObjectName == 'Processor' and CounterName == '% Idle Time' and InstanceName == '_Total') | summarize by $table
The properties of the first part of the query belong to Perf table.
Note, the “withsource = table” command adds a column that designates the table name that hosts the property.
union withsource = table * | where CounterName == '% Processor Utility' | summarize by table
The properties of the second part of the query also belong to Perf table.
2. Since the properties used in the query are from Perf table, both outer and inner queries start with Perf table and scope the query execution to that table.
Perf | where ObjectName == 'Processor' and CounterName == '% Idle Time' and InstanceName == '_Total' | where Computer !in ((Perf | where CounterName == '% Processor Utility' | summarize by Computer)) | summarize Avg_Idle_Time = avg(CounterValue) by Computer, CounterPath | where Avg_Idle_Time < 5 | count