string stsDiscoveryEndpoint = "https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration";

ConfigurationManager<OpenIdConnectConfiguration> configManager = new ConfigurationManager<OpenIdConnectConfiguration>(stsDiscoveryEndpoint);

OpenIdConnectConfiguration config = configManager.GetConfigurationAsync().Result;

TokenValidationParameters validationParameters = new TokenValidationParameters
            {
                ValidateAudience = false,
                ValidateIssuer = false,
                IssuerSigningTokens = config.SigningTokens,
                ValidateLifetime = false
            };

JwtSecurityTokenHandler tokendHandler = new JwtSecurityTokenHandler();

SecurityToken jwt;

            var result = tokendHandler.ValidateToken(token, validationParameters, out jwt);

return jwt as JwtSecurityToken;

#include "stdafx.h"
#include "Winsock.h"
#include <WinSock2.h>
#include <ws2bth.h>
#include <bthsdpdef.h>
#include <bluetoothapis.h>

#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "irprops.lib")

int main()
{
	if (!Winsock::InitialzedForCurrentProcess())
	{
		return 1;
	}

	Winsock winsock = Winsock(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);

	if (!winsock.IsValid())
	{
		return 1;
	}

	winsock.Bind();

	winsock.Listen();

	winsock.RegisterServcie(_T("RFCOMM Server Demo Instance"), _T("Pushing data to PC"), OBEXObjectPushServiceClass_UUID);

	winsock.OnConnected([](SOCKET s){
		char buffer[1024] = { 0 };

		memset(buffer, 0, sizeof(buffer));

		int r = 0;

		do
		{
			r = recv(s, (char*)buffer, sizeof(buffer), 0);

			printf("result:%d, %s\n", r, buffer);

		} while (r != 0);

		closesocket(s);
	});

	winsock.Accept();

	WSACleanup();

    return 0;
}

<UserControl
 x:Name="control"
 x:Class="WP81ControlsDemo.NumberPicker"
 xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="using:WP81ControlsDemo"
 xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
 xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006"
 mc:Ignorable="d"
 d:DesignHeight="50"
 d:DesignWidth="300">
 <Border
 BorderBrush="#FFF2F2F2" 
 BorderThickness="2"
 Width="{Binding ElementName=control, Path=Width}"
 Height="{Binding ElementName=control, Path=Height}"
 >
 </Border>
 </UserControl>

<Grid HorizontalAlignment="Stretch" Background="White">
 <Grid.ColumnDefinitions>
 <ColumnDefinition Width="50"></ColumnDefinition>
 <ColumnDefinition Width="*"></ColumnDefinition>
 <ColumnDefinition Width="50"></ColumnDefinition>
 </Grid.ColumnDefinitions>
 <Border 
 BorderBrush="#FFF2F2F2" 
 BorderThickness="0,0,3,0"
 Tapped="Reduce_Tapped"
 >
 <TextBlock 
 FontSize="25" 
 Grid.Column="0"
 HorizontalAlignment="Center"
 VerticalAlignment="Center"
 Foreground="#FF72D3FF"
 
 >-</TextBlock>
 </Border>
 <TextBlock
 x:Name="content"
 FontSize="25" 
 Grid.Column="1"
 HorizontalAlignment="Center"
 VerticalAlignment="Center"
 Foreground="#FF72D3FF"
 >0</TextBlock>
 <Border 
 BorderBrush="#FFF2F2F2" 
 BorderThickness="2,0,0,0"
 Grid.Column="2"
 Tapped="Increase_Tapped"
 >
 <TextBlock 
 FontSize="25" 
 HorizontalAlignment="Center"
 VerticalAlignment="Center"
 Foreground="#FF72D3FF"
 >+</TextBlock>
 </Border>
 </Grid>
 

public sealed partial class NumberPicker : UserControl
 {
 public NumberPicker()
 {
 this.InitializeComponent();
 }
 private void Reduce_Tapped(object sender, TappedRoutedEventArgs e)
 {
 var currentValue = int.Parse(content.Text);
 
 if(currentValue == 0)
 {
 return;
 }
 content.Text = (currentValue - 1).ToString();
 }
 
 private void Increase_Tapped(object sender, TappedRoutedEventArgs e)
 {
 var currentValue = int.Parse(content.Text);
 content.Text = (currentValue + 1).ToString();
 }
 }

private static bool Is<T>(UIElement obj) where T : UIElement

{

    return typeof(T).IsAssignableFrom(obj.GetType());

}

 

private static void FindElement<T>(Panel parent, ICollection<T> collection) where T : UIElement

{

    if (parent == null)

    {

        throw new ArgumentNullException("Augument parent can not be null!");

    }

    foreach (var ele in parent.Children)

    {

        if(Is<T>(ele))

        {

            collection.Add((T)ele);

        }else if(Is<Panel>(ele))

        {

            FindElement(ele as Panel, collection);

        }

    }

}

private static void AddEventHandler(Object target, string name, Delegate handler)

{

    var runtimeEvent = target.GetType().GetRuntimeEvent("Click");

 

    Func<Delegate, EventRegistrationToken> add = (a) => {

        return (EventRegistrationToken)runtimeEvent.AddMethod.Invoke(target, new object[] { a });

    };

 

    Action<EventRegistrationToken> remove = (a) => {

        runtimeEvent.RemoveMethod.Invoke(runtimeEvent, new object[] { a });

    };

 

    WindowsRuntimeMarshal.AddEventHandler(add, remove, handler);

}

List<Button> list = new List<Button>();

 

FindElement(this.Content as Panel, list);

 

var handlerMethodInfo = this.GetType().GetMethod("OnClick");

 

var delegateHandler = handlerMethodInfo.CreateDelegate(typeof(RoutedEventHandler), this);

 

foreach(var button in list)

{

    AddEventHandler(button, "Click", delegateHandler);

}

create_task(Windows::ApplicationModel::Package::Current->InstalledLocation->GetFileAsync("Assets\\StoreLogo.png")).then([this](StorageFile^ file) {              

              HANDLE hFile = CreateFile2(file->Path->Data(), // lpFileName

                     GENERIC_READ,                        // dwDesiredAccess

                     FILE_SHARE_READ,                     // dwShareMode

                     OPEN_EXISTING,                       //

                     NULL);

              FILETIME lastModify;

              SYSTEMTIME systemTime;

              GetFileTime(hFile, NULL, NULL, &lastModify);

              FileTimeToSystemTime(&lastModify, &systemTime);

              CloseHandle(hFile);

       });

 

        const uint GENERIC_READ             = 0x80000000;

        const uint FILE_SHARE_READ          = 0x00000001;

        const uint OPEN_EXISTING            = 3;



 [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]

        private static extern SafeFileHandle CreateFile2(

            string lpFileName,

            uint dwDesiredAccess,

            uint dwShareMode,

            uint dwCreationDisposition,

            IntPtr pCreateExParams);



 [DllImport("kernel32.dll")]

        static extern bool GetFileTime(

            IntPtr hFile,

            ref FILETIME lpCreationTime,

            ref FILETIME lpLastAccessTime,

            ref FILETIME lpLastWriteTime);





 [DllImport("kernel32.dll", SetLastError = true)]

 [return: MarshalAs(UnmanagedType.Bool)]

        private static extern bool CloseHandle(IntPtr hObject);



 [StructLayout(LayoutKind.Sequential)]

        private struct FILETIME

        {

            public uint dwLowDateTime;

            public uint dwHighDateTime;

        }

 

        private async void Button_Click(object sender, RoutedEventArgs e)

        {

            var file = await Windows.ApplicationModel.Package.Current.InstalledLocation.GetFileAsync(@"Assets\StoreLogo.png");

 

            FILETIME fCreationTime = new FILETIME();

            FILETIME fLastAccessTime = new FILETIME();

            FILETIME fLastWriteTime = new FILETIME();

 

            var hFile = CreateFile2(file.Path, GENERIC_READ, FILE_SHARE_READ, OPEN_EXISTING, IntPtr.Zero);

 

            GetFileTime(hFile.DangerousGetHandle(), ref fCreationTime, ref fLastAccessTime, ref fLastWriteTime);

 

            var lastWriteTime = DateTime.FromFileTimeUtc((((long)fLastWriteTime.dwHighDateTime) << 32) | ((uint)fLastWriteTime.dwLowDateTime));

 

            hFile.DangerousRelease();

        }

[ComImport]

[Guid("5b0d3235-4dba-4d44-865e-8f1d0e4fd04d")]

[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]

unsafe interface IMemoryBufferByteAccess

{

  void GetBuffer(out byte* buffer, out uint capacity);

}

#2 Get the underlying interface

if (reference is IMemoryBufferByteAccess)

{

  // Get a pointer to the pixel buffer

  byte* data;

  uint capacity;

 

  ((IMemoryBufferByteAccess)reference).GetBuffer(out data, out capacity);

  ********

}

MIDL_INTERFACE("5b0d3235-4dba-4d44-865e-8f1d0e4fd04d")

IMemoryBufferByteAccess : IUnknown

{

       virtual HRESULT STDMETHODCALLTYPE GetBuffer(

              BYTE   **value,

              UINT32 *capacity

              );

};

ComPtr<IMemoryBufferByteAccess> bufferByteAccess;

HRESULT result = reinterpret_cast<IInspectable*>(reference)->QueryInterface(IID_PPV_ARGS(&bufferByteAccess));

if (result == S_OK)

{

  WriteLine("Get interface successfully");

  BYTE* data = nullptr;

  UINT32 capacity = 0;

  result = bufferByteAccess->GetBuffer(&data, &capacity);

  if (result == S_OK)

  {

    WriteLine("get data access successfully, capacity: " + capacity);

  }

}

#include "stdafx.h"
#include <Windows.Foundation.h>
#include <wrl\wrappers\corewrappers.h>
#include <wrl\client.h>
#include <iostream>
#include <sstream>

using namespace std;
using namespace ABI::Windows::Foundation;
using namespace Microsoft::WRL;
using namespace Microsoft::WRL::Wrappers;

int main()
{
	// Initialize the Windows Runtime.
	RoInitializeWrapper initialize(RO_INIT_MULTITHREADED);

	if (FAILED(initialize))
	{
		cout << "Failed to initialize";
	}

	// Get the activation factory for the IUriRuntimeClass interface.
	ComPtr<IUriRuntimeClassFactory> uriFactory;

	HRESULT hr = GetActivationFactory(HStringReference(RuntimeClass_Windows_Foundation_Uri).Get(), &uriFactory);

	if (FAILED(hr))
	{
		cout << "failed to activate the Windows Runtime Class Factory";

		return 0;
	}

	// Create a string that represents a URI.

	HString uriHString;

	hr = uriHString.Set(L"https://www.microsoft.com");

	if (FAILED(hr))
	{
		cout << "failed to wrapper the string";

		return 0;
	}

	// Create the IUriRuntimeClass object.
	ComPtr<IUriRuntimeClass> uri;

	hr = uriFactory->CreateUri(uriHString.Get(), &uri);

	if (FAILED(hr))
	{
		cout << "failed to create a runtime instance";

		return 0;
	}

	// Get the domain part of the URI.
	HString domainName;

	hr = uri->get_Domain(domainName.GetAddressOf());

	if (FAILED(hr))
	{
		cout << "failed to call method get_Domain";

		return 0;
	}

	wprintf_s(L"Domain name: %s\n", domainName.GetRawBuffer(nullptr));

    return 0;
}