Today's Little Program creates a listview with checkboxes on some items but not other.

The LVS_EX_CHECK­BOXES extended style is really just a convenience style. Everything it does you could have done yourself, with a bit more typing.

• It creates a state image list consisting of an unchecked box (state 1) and a checked box (state 2). You could have done this yourself with Image­List_Create followed by a few calls to Draw­Frame­Control.
• When you hit the space bar or click on the check box, the state image toggles between 1 and 2. You could have done this yourself by responding to LVN_KEY­DOWN (for the space bar), and the mouse notification messages for the clicks. (For the mouse notifications, see if the click was on LVHT_ON­ITEM­STATE­ICON.)

But still, it's convenient having the listview control do this grunt work for you. But what if you want to remove the check box from some items?

The listview control turns on the state image and toggles it by doing the moral equivalent of a List­View_Set­Check­State on the item, so all you have to do is respond to the LVN_ITEM­CHANGING that comes with any item change and reject the state change.

Start with our scratch program and make these changes. Remember, Little Programs do little or no error checking.

BOOL
OnCreate(HWND hwnd, LPCREATESTRUCT lpcs)
{
  g_hwndChild = CreateWindow(WC_LISTVIEW, NULL,
        WS_CHILD | WS_VISIBLE | LVS_REPORT,
        0, 0, 0, 0, hwnd, (HMENU)1, g_hinst, 0);
  ListView_SetExtendedListViewStyle(g_hwndChild,
                                    LVS_EX_CHECKBOXES);
  LVCOLUMN col;
  col.mask = LVCF_TEXT | LVCF_WIDTH;
  col.cx = 200;
  col.pszText = TEXT("Name");
  ListView_InsertColumn(g_hwndChild, 0, &col);
  LVITEM item;
  item.mask = LVIF_TEXT;
  item.iSubItem = 0;
  item.pszText = TEXT("Alpha");
  ListView_InsertItem(g_hwndChild, &item);
  item.pszText = TEXT("Beta");
  ListView_InsertItem(g_hwndChild, &item);
  item.pszText = TEXT("Gamma");
  ListView_InsertItem(g_hwndChild, &item);
  item.pszText = TEXT("Delta");
  ListView_InsertItem(g_hwndChild, &item);
  return TRUE;
}

Okay, so far the program adds four items, each with a check box. But let's say we want to remove the check boxes from the even-numbered items.

LRESULT
OnNotify(HWND hwnd, int idFrom, NMHDR *pnm)
{
  if (idFrom == 1) {
    switch (pnm->code) {
    case LVN_ITEMCHANGING:
      {
        LPNMLISTVIEW pnmlv = CONTAINING_RECORD(pnm, NMLISTVIEW, hdr);
        if (pnmlv->iItem >= 0 &&
        if (pnmlv->iItem % 2 == 0 &&
            (pnmlv->uChanged & LVIF_STATE)) {
         return TRUE; // reject changes to even-numbered items
        }
      }
      break;
    }
  }
  return 0;
}

    HANDLE_MSG(hwnd, WM_NOTIFY, OnNotify);

We add a handler for LVN_ITEM­CHANGING that says, "If this is a notification for an even-numbered item, and they want to change the state, then block the state change." This ensures that nobody can turn on the state image, which means that the checkbox never shows up.

I draw your attention to this research paper from Professor Mike Adams from Eastern Connecticut State University titled The Dead Grandmother/Exam Syndrome, also published in The Annals of Improbable Research. In the paper, Adams investigates the phenomenon he summarizes as follows:

A student's grandmother is far more likely to die suddenly just before the student takes an exam than at any other time of the year.

He takes twenty years of historical data and confirms the existence of the phenomenon, thereby drawing attention to an important but overlooked national health problem: Increased mortality of women with grandchildren in college during the weeks leading up to exams.

• If there is no exam imminent, the death rate is independent of how well the student is doing in class.
• As a midterm nears, the death rate goes up by a factor of ten. As a final looms, it goes up by a factor of 19.
• The effect is strongly dependent on how well the student is doing in class. Grandmothers of students doing poorly are at much greater risk. A grandmother of a failing student is 50 times more likely to die in the week prior to a final than a grandmother of a top student when there is no examination imminent.
• Grandmothers are 24 times more likely to die than grandfathers.
• The effect is independent of family size.

Adams develops theories which attempt to explain these phenomena and also has some proposals for addressing the effect.

A follow-up study by professor Lee Jussim of Rutgers University examined ways of addressing this enormous danger posed to grandmothers. In A Preliminary Report on an Intervention Designed to Reduce Grandmother Death Resulting From College Exams, Jussim found a way to save the lives of 4 out of 5 grandmothers during the lead-up to exams: Inform students that the make-up exam will be brutally difficult.

Bonus chatter: The articles are written tongue-in-cheek, but other less whimsical explanations for the observed behavior include

• If a grandmother passes when no exam is imminent, the student will miss class without explanation.
• Good students are less likely to ask for assistance with exams even if they lose a grandmother.
• A student with an ill grandmother is more likely to have poor grades due to stress/worry.

Note also that the predicted grandmother popular collapse did not come to pass. One theory is that this was prevented due to another phenomenon: Grade inflation.

A couple of customers recently reported this interesting issue with Outlook views and custom form icons:

1. Publish a custom form in Outlook and chosen to give it an icon. There doesn’t need to be anything special about the form. In fact, the default custom form icon will reproduce this issue.
2. Configure a folder with the Table view (single line, with rows and columns). One way to do this is to turn off the Reading pane and make the view wide enough that Outlook defaults to the Table.
3. Create a new item using your form.

Expected: The entry in the table uses the custom icon.

Actual: The entry in the table has no icon.

Further, if you narrow the view so that it switches to two line mode, you’ll see the icon appear, and it will continue to be used even if you switch back to the Table view.

The problem stems from the logic we use to determine when we can go back to the forms manager to get the icon. We don’t want to hit the forms manager while we’re rendering the view since this could cause a network call which would slow everything down. So we decide we’ll go get the icon later. Except later never happens for this view. The other views don’t have this flaw – only the Table view. We’re working on a fix for this. I’ll post back here when the fix is ready.

Posted By Olivia Chen
Senior Product Marketing Manager

The fitting room is the crucial place where a customer decides whether to make a purchase. But most of the time, the customer is alone and behind a curtain or door when that decision is made, without any support or assistance from the retailer. At the National Retail Federation Big Show 2014 in New York, Microsoft and Accenture demonstrated the “Connected Fitting Room,” an experience that brings technology into the last “dark channel” of retail: the brick-and-mortar store.

In many retail stores, associates and managers have little insight into what the potential intelligence fitting room can provide their business. For example, a customer may try on a pair of jeans, find that they don’t fit, and leave them behind without the retailer ever knowing anyone was there — or associates and managers knowing the store just lost a sale. And a pile of un-purchased clothing on the dressing room floor doesn’t tell the store manager if the customer wanted a different size, didn’t like the style, or just got impatient trying to flag down a sales associate for help.

In the above video, Brendan Mislin, Global Capability Lead for Windows platforms at Accenture and Brendan O’Meara, Managing Director for the Worldwide Retail Industry at Microsoft discuss how a connected fitting room spanning multiple devices can revolutionize the shopping experience for customers, associates and store managers alike. The technology helps customers find what they came for and discover additional items that fit their interests, and helps businesses better understand and meet customers’ needs, drive informed merchandising decisions and boost sales associate productivity.

The Connected Fitting Room is on display at the Microsoft booth (#2703) at NRF’s Big Show through January 14. Read more about this solution on the Windows for Your Business blog post from NRF. Read more about Microsoft’s vision for retail on the Windows Embedded retail page.

Just a quick note today that our job posting is live at https://careers.microsoft.com/jobdetails.aspx?ss=&pg=0&so=&rw=1&jid=133405&jlang=EN&pp=SS.  We are looking for a senior level tester to come in and help with increasing the quality of the code we share across all clients.

If you have the experience and drive, feel free to let me know or just apply directly.  I look forward to speaking to you if you do!

Questions, comments, concerns and criticisms always welcome,
John

Sam Guckenheimer and I will be traveling to Germany next month to participate in the German ALM Days event Feb 24 – 26.  We’ll be talking a lot about engineering on a cloud cadence among other things.  If you are interested/able, we’d love to see you there.  Of course, I think, all of the conference, except my part, will be in German .

Brian

Som noget helt nyt tilbyder LESSOR et integreret lønsystem til Microsoft Dynamics C5 2014 - og i den anledning inviterer LESSOR til informationsmøde, hvor du kan høre om dine forretningsmuligheder ved at blive partner på løsningen. Du får stærke kort på hånden i forhold til både nye og eksisterende kunder, og du får en lang række fordele i form af blandt andet salgsstøtte og systemsupport.

LESSOR Payroll er en unik lønløsning, der er tæt integreret til både Microsoft Dynamics C5 2014 og Microsoft Dynamics NAV. Med deres mangeårige erfaring inden for lønsystemer til Microsoft Dynamics-familien er introduktionen af Payroll til Microsoft Dynamics C5 2014 en naturlig udvidelse af produktporteføljen – og vi tror på, at markedspotentialet er stort.

Derfor inviteres du til at høre om, hvordan du som LESSOR-partner kan få del i forretningen.

Tid og sted
Du kan vælge mellem at deltage i Jylland eller på Sjælland. Begge steder bydes morgenmad inden selve programmet starter. Informationsmødet foregår:

• Torsdag, den 6. marts 2014, kl. 9.00 - 11.00 på Scandic Bygholmspark, Schuttesvej 6, 8700 Horsens
• Fredag, den 7. marts 2014, kl. 9.00 - 11.00 på Scandic Hvidovre, Kettevej 4, 2650 Hvidovre

Sådan kommer du med
Klik ind på http://www.lessor.dk/C5 og tilmeld dig. Deltagelse er naturligvis gratis.

Vi glæder os til at byde dig velkommen!

Med venlig hilsen

LESSOR

I am excited to announce the release of Microsoft Dynamics Business Analyzer to the Windows 8 Phone store!  This release marks another milestone for Dynamics GP team.  Over the past year we have released the complete web client solution, our first Windows 8 companion app, an O365 Dashboard template, and now have released our first application for the Windows 8 phone. This continues our strategy of a web client solution surrounded by the Apps that make sense for the right users.

Microsoft Dynamics Business Analyzer for WP8 enables our customers to view and take action on information that is vital for running their businesses right from their Windows 8 Phone.   In today’s mobile environment it is the perfect application to enable users to stay connected to important information at all times.

A fim de facilitar o acesso aos recursos presentes na internet, para utilizar Microsoft Dynamics CRM 2013, envio uma lista de atalhos em português (quando disponíveis):

Microsoft Dynamics CRM Server 2013

http://www.microsoft.com/pt-pt/download/details.aspx?id=40341

Microsoft Dynamics CRM 2013 para Microsoft Office Outlook (Cliente Outlook)

http://www.microsoft.com/pt-pt/download/details.aspx?id=40344

Router de Correio Eletrónico da Microsoft Dynamics CRM 2013

http://www.microsoft.com/pt-pt/download/details.aspx?id=40342

Pacotes de Idiomas da Microsoft Dynamics CRM 2013

http://www.microsoft.com/pt-pt/download/details.aspx?id=40340

Microsoft Dynamics CRM para Windows 8

http://apps.microsoft.com/windows/en-us/app/microsoft-dynamics-crm/93772212-7b72-4aee-bc4e-b1adb7712ebe

Microsoft Dynamics CRM para iPad

https://itunes.apple.com/us/app/microsoft-dynamics-crm/id678800460?mt=8

Extensões para Microsoft Dynamics CRM 2013:

Extensão de Criação de Relatórios da Microsoft Dynamics CRM 2013 (com suporte para SQL Server Data Tools)

http://www.microsoft.com/pt-pt/download/details.aspx?id=40343

Componente de Lista do Microsoft Dynamics CRM 2013 para Microsoft SharePoint Server 2010 e Microsoft SharePoint Server 2013 (para vários browsers)

http://www.microsoft.com/pt-pt/download/details.aspx?id=40345

Recursos e informação complementar:

Microsoft Dynamics CRM 2013 IG

http://www.microsoft.com/en-us/download/details.aspx?id=40322

Microsoft Dynamics CRM 2013 Software Development Kit (SDK version 6.0.2)

http://www.microsoft.com/en-us/download/details.aspx?id=40321

CRM Customer Center

http://www.microsoft.com/en-us/dynamics/crm-customer-center/default.aspx

Luís Filipe.

A Microsoft disponibilizou o Update Rollup 1. Trata-se de um conjunto cumulativo e testado de atualizações para a Microsoft Dynamics CRM 2013. Inclui melhoramentos de desempenho que são agrupados para simplificar a implementação.

Para mais Informações sobre o Update Rollup 1, poderá aceder ao seguinte artigo: http://support.microsoft.com/kb/2891271.

Transferência da versão portuguesa do Update Rollup 1 para Microsoft Dynamics CRM 2013: http://www.microsoft.com/pt-pt/download/details.aspx?id=41546.

Obrigado.

Luís Filipe.

Quality reports on the App Summary page

Microsoft provides triage dumps of your Windows Store application’s crashes and hangs through the Quality section of the App Summary page on the Dev Center - Windows Store apps portal.

Back in June 2012, the Windows Store team posted an article on this feature and the basics of debugging the dumps provided.  Improving apps with Quality reports,

http://blogs.msdn.com/b/windowsstore/archive/2012/06/27/improving-apps-with-quality-reports.aspx.

This article digs further into the debugging of Windows Store application crash dump files, and explains the recent changes made to exception reporting in Windows 8.1.

The files being debugged can be obtained from the Quality page or by collecting them yourself using Windows Error Reporting (WER) or the AeDebug feature of Windows.

An example AeDebug tool is Sysinternals ProcDump. To configure crash dumping, execute the following from an elevated command prompt:

C:\>md c:\dumps

C:\>procdump.exe -ma -i c:\dumps

Windows Runtime Architecture

The Windows Runtime (WinRT API) is at the core of all Windows Store applications. Similar to how Win32 and.NET sit between the Desktop app and the kernel, the WinRT API sits between the Windows Store app and the kernel.

In between the WinRT API and app is a layer called the Language Projection layer. This layer projects the C++ centric concepts of WinRT, into language specific concepts.

The projection of errors through the Language Projection layer is the focus of this article.

• In WinRT, errors are modeled as IErrorInfo and IRestrictedErrorInfo interfaces.
• In CLR languages, errors are modeled as exceptions and are represented as class objects derived from System.Exception.
• In JavaScript, errors are also modeled as exceptions and are represented as JavaScript Exception (JSE) objects.
• In C/C++, errors are modeled as an interface or a pure HRESULT.

Because each language has a different concept on how errors are handled, the projection layer needs to use a least common denominator. For errors, that means that just an HRESULT (Error Code) and HSTRING (Error Message) are sent through the projection layer. Any addition information held by WinRT’s interface is not available in the receiving language. And conversely, any additional information held by the language’s object is not available to WinRT.

If the error becomes unhandled, the HRESULT becomes the Exception Code reported in the Exception Record (of a live debug session or dump file).

Visual Studio 2013

Opening a dump file in Visual Studio allows you to see the Exception Record via the MiniDump File Summary. The Exception Code is listed in the Dump Summary section.

If you Debug the application, the Exception Code‘s Description will be listed in the Output window.

The call stack of the Exception Record’s context is viewable in the Call Stack window. Depending on the dump’s state, the $exceptionstack pseudo variable can be used in a Watch (or Locals) window to see the stack.

Note, having the Private PDBs of the application will make the stack output more complete/accurate.

Debugging Tools for Windows

Using the Debugging Tools for Windows, the Exception Record can be displayed using the .exr -1 command. The Exception Code’s description can (sometimes) be looked up using the !error <code> command. The context of the exception is changed to with the .ecxr command. The stack is displayed with the k command (knL adds frame numbers and omits source line information).

0:004> .exr -1

ExceptionAddress: 722248e8 (msvcr110!Concurrency::details::_ReportUnobservedException+0x00000022)

   ExceptionCode: c0000409 (Security check failure or stack buffer overrun)

  ExceptionFlags: 00000001

NumberParameters: 1

   Parameter[0]: 00000005

0:004> !error c0000409

Error code: (NTSTATUS) 0xc0000409 (3221226505) - The system detected an overrun of a stack-based buffer in this application. This overrun could potentially allow a malicious user to gain control of this application.

0:004> .ecxr

eax=00000001 ebx=ffffffff ecx=00000005 edx=0a6ee048 esi=13672424 edi=0546c33c

eip=722248e8 esp=02ceeef8 ebp=02ceef14 iopl=0         nv up ei pl nz na po nc

cs=0023  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00000202

msvcr110!Concurrency::details::_ReportUnobservedException+0x22:

722248e8 cd29            int     29h

0:004> knL

  *** Stack trace for last set context - .thread/.cxr resets it

# ChildEBP RetAddr 

00 02ceeef4 00f2f6cb msvcr110!Concurrency::details::_ReportUnobservedException+0x22

WARNING: Stack unwind information not available. Following frames may be wrong.

01 02ceef14 00f2fad7 MyBadApp+0xef6cb

02 02ceef40 01122720 MyBadApp+0xefad7

03 02ceef64 011228eb MyBadApp+0x2e2720

04 02ceef70 00f3960a MyBadApp+0x2e28eb

05 02ceefb0 010cc804 MyBadApp+0xf960a

06 02ceefc0 0112108e MyBadApp+0x28c804

07 02ceeff8 72422b61 MyBadApp+0x2e108e

08 02cef034 72427e27 Microsoft_Xbox!DllGetClassObject+0x61352

09 02cef040 76095c3e Microsoft_Xbox!DllGetClassObject+0x66618

0a 02cef060 7610f497 rpcrt4!Invoke+0x2a

0b 02cef6ec 75c241f8 rpcrt4!NdrStubCall2+0x33c

0c 02cef734 75c1f58a combase!CStdStubBuffer_Invoke+0xc1

0d 02cef7c0 75b24617 combase!SyncStubInvoke+0x144

0e (Inline) -------- combase!StubInvoke+0x9a

0f 02cef8e8 75b97d8d combase!CCtxComChnl::ContextInvoke+0x222

10 02cef90c 75c24cc9 combase!DefaultInvokeInApartment+0x30

11 (Inline) -------- combase!ASTAInvokeInApartment+0x35

12 02cef9b4 75c1fdc7 combase!AppInvoke+0x5ae

13 02cefb00 75c24c71 combase!ComInvokeWithLockAndIPID+0x5ed

14 02cefb20 75b93118 combase!ComInvoke+0x153

15 02cefb30 75b97b11 combase!ThreadDispatch+0x23

16 02cefb44 75be53b5 combase!CComApartment::ASTAHandleMessage+0xe6

17 02cefb68 75ba8f22 combase!ASTAWaitContext::DispatchCallsOnExitNonBlockingProcessEventsIfAppropriate+0x9e

18 02cefb8c 75b5917e combase!ASTAWaitContext::~ASTAWaitContext+0x1a9

19 02cefb98 74acb13d combase!CoEndProcessEvents+0x37

1a 02cefbf4 00f733d7 windows_ui!Windows::UI::Core::CDispatcher::ProcessEvents+0x29ac1

1b 02cefc64 00f77f46 MyBadApp+0x1333d7

1c 02cefc94 74f6f45e MyBadApp+0x137f46

1d 02cefca0 74f6f322 twinapi_appcore!Windows::ApplicationModel::Core::CoreApplicationView::Run+0x27

1e 02cefcc0 74b1008a twinapi_appcore!<lambda_f0454c86bc54370cf843d844d6c13e00>::operator()+0xb2

1f 02cefd44 75f4a534 SHCore!_WrapperThreadProc+0xe2

20 02cefd50 77dd8f8b kernel32!BaseThreadInitThunk+0xe

21 02cefd94 77dd8f61 ntdll!__RtlUserThreadStart+0x20

22 02cefda4 00000000 ntdll!_RtlUserThreadStart+0x1b

Simple so far...

Using Visual Studio or the Debugging Tools for Windows is relatively simple when the Exception Record is associated with the call stack of the issue. This is not however always the case. It depends on what side of the projection layer the issue occurred. If the error (exception) was not handled on the language side, the exception is marshaled (projected) to the WinRT side for its exception handling. When this occurs, it starts getting very, very tricky indeed, to see what stack caused the issue...

Language Exceptions - Error Code 0xC000027B

In the initial design of the WinRT API, the projection of errors was done though a call to the RoOriginateError function. This function takes a HRESULT and HSTRING. Of note, there is no call stack captured. The limits of the RoOriginateError function were recognized and a new (associated) function was created for Windows 8.1.

The RoOriginateLanguageException function takes a HRESULT, HSTRING and a marshalable interface pointer. When RoOriginateLanguageException in called, the current call stack is captured and is passed as part of the error.

The purpose of RoOriginateLanguageException is to marshal the interface pointer so that additional language information is available on the other side of the projection layer. This behavior is achieved by using a specific exception code. Instead of the using the (user defined) HRESULT, a value of 0xC000027B is used. This error code indicates to the receiver that there is data to unmarshal. The data includes the HRESULT and HSTRING, and also the Interface pointer.

The important point to understand here is that all async exceptions raised in Windows 8.1 Windows Store apps now result in a 0xC000027B error code in the Exception Record, not the error code passed by the caller.

Debugging Language Exceptions

The Exception Record of a Language Exception contains (of note) the exception code (0xC000027B) and two parameters.

0:004> .exr -1

ExceptionAddress: 73034fec (Windows_UI_Xaml!DirectUI::ErrorHelper::ProcessUnhandledError+0x000000b8)

   ExceptionCode: c000027b

  ExceptionFlags: 00000001

NumberParameters: 2

   Parameter[0]: 0bdaf240

   Parameter[1]: 00000001

0:006> !error c000027b

Error code: (NTSTATUS) 0xc000027b (3221226107) - An application-internal exception has occurred.

The first parameter is the address of a pointer array (of unmarshalled data). The second parameter is the count of pointers in the pointer array.

So why is the need for a count?  Since applications have multiple threads, it is possible for multiple threads to call RoOriginateLanguageException simultaneously. Equally, there can be a cyclic nature to the experience, where exceptions are caught and then re-thrown. Since WinRT processes the errors asynchronously, multiple errors exist regularly. The first exception in the array should be the focus of the investigation.

[Tip] Even though Microsoft publishes the private symbols for combase.dll (allowing you to view the local variables of combase!RoFailFast* functions), these locals regularly resolve to invalid addresses due to register reuse and other code flow optimizations. The pointer array in Parameter[0] is the correct place to get the address of the language exception pointer array.

Original Error Code

The first step when debugging a Language Exception is to determine the actual error code of the caller, instead of the 0xC000027B error code.

Casting an address to a pointer array of a specific type in Visual Studio is, put simply, too difficult to undertake. The easiest option is to use the Debugging Tools for Windows. Even though these tools are all command-line driven and use an obscure syntax, it is relatively easy to follow the following commands to get to the important information.

If not done already, set your symbol path to the Microsoft Public Symbol server:

0:004> .sympath SRV*C:\Symbols*http://msdl.microsoft.com/download/symbols

Symbol search path is: SRV*C:\Symbols*http://msdl.microsoft.com/download/symbols

Expanded Symbol search path is: srv*c:\Symbols*http://msdl.microsoft.com/download/symbols

************* Symbol Path validation summary **************

Response                         Time (ms)     Location

Deferred                                       SRV*C:\Symbols*http://msdl.microsoft.com/download/symbols

Force the load of the symbols using the .reload /f command:

0:004> .reload /f

...

The next step is to display the pointer array as the original structure type. First, we need to know what structure to cast the pointer array to. Using the Parameter[0] value from .exr -1, we will generate a dt command that will display the header of the first record. We use Parameter[0] as the address in this command.

dt <Parameter[0]> combase!_STOWED_EXCEPTION_INFORMATION_HEADER*

Here’s an example:

0:004> .exr -1

ExceptionAddress: 73034fec (Windows_UI_Xaml!DirectUI::ErrorHelper::ProcessUnhandledError+0x000000b8)

   ExceptionCode: c000027b

  ExceptionFlags: 00000001

NumberParameters: 2

   Parameter[0]: 0180cf90

   Parameter[1]: 00000003

0:004> dt 0180cf90 combase!_STOWED_EXCEPTION_INFORMATION_HEADER*

0x070884a4

   +0x000 Size             : 0x20

   +0x004 Signature        : 0x53453031

The value of the Signature member (0x53453031) is converted to a string using .formats <value>.

0:006> .formats 0x53453031

Evaluate expression:

  Hex:     53453031

  Decimal: 1397043249

  Octal:   12321230061

  Binary:  01010011 01000101 00110000 00110001

  Chars:   SE01

  Time:    Wed Apr 09 04:34:09 2014

  Float:   low 8.46917e+011 high 0

  Double:  6.90231e-315

The chars “SE01” map to a structure name of combase!_STOWED_EXCEPTION_INFORMATION_V1. It can be assumed that v2 uses a signature of “SE02” and a structure name of combase!_STOWED_EXCEPTION_INFORMATION_V2, and so on…

Now we know the type, we can again use the values from .exr -1 to generate a dt command that will display each record. We use the Parameter[0] as the address, and Parameter[1] as the count in the command. We add an “*” to the end of the type as this is an array of pointers to the type, not structures packed next to each other.

In this example, there are 3 pointers, so 3 records are displayed:

dt -a<Parameter[1]><Parameter[0]> combase!_STOWED_EXCEPTION_INFORMATION_V1*

Note, there is no space between the -a and <Parameter[1]>.

0:004> .exr -1

ExceptionAddress: 73034fec (Windows_UI_Xaml!DirectUI::ErrorHelper::ProcessUnhandledError+0x000000b8)

   ExceptionCode: c000027b

  ExceptionFlags: 00000001

NumberParameters: 2

   Parameter[0]: 0180cf90

   Parameter[1]: 00000003

0:004> dt -a30180cf90 combase!_STOWED_EXCEPTION_INFORMATION_V1*

[0] @ 0180cf90

---------------------------------------------

0x070884a4

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 80131500

   +0x00c ExceptionForm    : 0y01

   +0x00c ThreadId         : 0y000000000000000000010100111100 (0x53c)

   +0x010 ExceptionAddress : 0x7721ea23 Void

   +0x014 StackTraceWordSize : 4

   +0x018 StackTraceWords  : 5

   +0x01c StackTrace       : 0x06f48418 Void

   +0x010 ErrorText        : 0x7721ea23  "?????"

[1] @ 0180cf94

---------------------------------------------

0x071ca274

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 80131500

   +0x00c ExceptionForm    : 0y01

   +0x00c ThreadId         : 0y000000000000000000010100111100 (0x53c)

   +0x010 ExceptionAddress : (null)

   +0x014 StackTraceWordSize : 4

   +0x018 StackTraceWords  : 0x19

   +0x01c StackTrace       : 0x071c926c Void

   +0x010 ErrorText        : (null)

[2] @ 0180cf98

---------------------------------------------

0x071c922c

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 80131534

   +0x00c ExceptionForm    : 0y01

   +0x00c ThreadId         : 0y000000000000000000010100111100 (0x53c)

   +0x010 ExceptionAddress : (null)

   +0x014 StackTraceWordSize : 4

   +0x018 StackTraceWords  : 9

   +0x01c StackTrace       : 0x071c8224 Void

   +0x010 ErrorText        : (null)

The ResultCode member is 80131500 in the first two records, and 80131534 in the third record. A quick use of the !error <code> command looks up the descriptions:

0:007> !error 80131500

Error code: (HRESULT) 0x80131500 (2148734208) - <Unable to get error code text>

0:007> !error 80131534

Error code: (HRESULT) 0x80131534 (2148734260) - <Unable to get error code text>

In this case, both aren‘t well-known error codes. This is common as API specific error codes aren’t in the OS error lookup routines.

Here are some examples of known error codes, found by looking at a random selection of dumps. Some are quite common (80004003, 80004005 and 80070057) while others are quite rare:

0:004> !error 80004003

Error code: (HRESULT) 0x80004003 (2147500035) - Invalid pointer

0:004> !error 80004005

Error code: (HRESULT) 0x80004005 (2147500037) - Unspecified error

0:005> !error 8000ffff

Error code: (HRESULT) 0x8000ffff (2147549183) - Catastrophic failure

0:004> !error 80070057

Error code: (HRESULT) 0x80070057 (2147942487) - The parameter is incorrect.

0:006> !error 80073db8

Error code: (HRESULT) 0x80073db8 (2147958200) - Loading the state store failed.

0:005> !error 800f1000

Error code: (HRESULT) 0x800f1000 (2148470784) - No installed components were detected.

0:006> !error 88985004

Error code: (HRESULT) 0x88985004 (2291683332) - A font file exists but could not be opened due to access denied, sharing violation, or similar error.

Original Call Stack

Regardless of whether the error code is known or unknown, it is useful to determine the location of the issue by viewing the call stack.

Symbol Pointers

If the ExceptionForm member has a value of 0y01, the structure’s union represents a call stack.

Unlike call stacks associated with threads, where the symbol pointers are placed throughout the stack next to local variables, these symbols pointers are packed tightly at the address specified in the StackTrace member. The dpS command is used to display the call stack.

• It is important to include a limit (L) as the call stack is regularly longer than the default 10 rows displayed by dpS. The limit’s value is in the StackTraceWords member.
• Note that capital S is used (dps vs dpS) because we want to omit the first column normally displayed by dps; the location of the symbol pointer is irrelevant.
• If you aren‘t using the same bitness debugger as the target’s bitness, use ddS for StackTraceWordSize = 4, and dqS for StackTraceWordSize = 8.

0:004> dt -a3 0180cf90 combase!_STOWED_EXCEPTION_INFORMATION_V1*

[0] @ 0180cf90

---------------------------------------------

0x070884a4

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 80131500

   +0x00c ExceptionForm    : 0y01

   +0x00c ThreadId         : 0y000000000000000000010100111100 (0x53c)

   +0x010 ExceptionAddress : 0x7721ea23 Void

   +0x014 StackTraceWordSize : 4

   +0x018 StackTraceWords  : 5

   +0x01c StackTrace       : 0x06f48418 Void

   +0x010 ErrorText        : 0x7721ea23  "?????"

...

0:007> dpS 0x06f48418 L5

7723f217 combase!RoOriginateLanguageException+0x3b

72e29bfd clr!SetupErrorInfo+0x1e1

72ef27e1 clr!MarshalNative::GetHRForException_WinRT+0x7d

71981170 Windows_UI_Xaml_ni+0x291170

72b02a36 clr!COMToCLRDispatchHelper+0x28

Unicode String Pointer

If the ExceptionForm member has a value of 0y10, the structure’s union represents an error message.

The call stack is (hopefully) contained within the Unicode string pointed at by the ErrorText member. As the text is defined by the caller, the existence of a call stack text isn’t guaranteed.

0:005> dt –a1 13f117e0 combase!_STOWED_EXCEPTION_INFORMATION_V1*

[0] @ 13f117e0

---------------------------------------------

0x0471f3c0

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 8000ffff

   +0x00c ExceptionForm    : 0y10

   +0x00c ThreadId         : 0y000000000000000000010101110100 (0x574)

   +0x010 ExceptionAddress : 0x0de38f7c Void

   +0x014 StackTraceWordSize : 0

   +0x018 StackTraceWords  : 0

   +0x01c StackTrace       : (null)

   +0x010 ErrorText        : 0x0de38f7c  "System.Exception..   at Windows.UI.Xaml.VisualStateManager.GoToState(Control control, String stateName, Boolean useTransitions)..   at MyBadApp.Common.LayoutAwarePage.InvalidateVisualState()..   at MyBadApp.Common.LayoutAwarePage.WindowSizeChanged(Object sender, WindowSizeChangedEventArgs e)"

CLR - Last Exception Object

Sometimes, the call stack retrieved from the record isn’t that useful. It may just be the call stack leading up to RoOriginateLanguageException function call, or it just might not relate to any of the code that the application author has written. In these cases, the CLR provides one more chance to understand the issue.

When the CLR throws an exception on a managed thread, the address of the exception object is kept in an (internal) per-thread variable. This address is what the !sos.pe (print exception) command reads to display the CLR Last Exception of a thread.

Note, if you use the Windows 8.1 SDK version of the Debugging Tools for Windows, SOS will be automatically loaded for you, including the download of any required DLLs. As such, it is highly suggested that you use the Windows 8.1 version.

Example #1

Looking at this example, we can see that there is a single record with an "Invalid pointer" error.

0:006> .exr -1

ExceptionAddress: 00007ffb87c46960 (twinapi_appcore!Microsoft::WRL::ComPtr<Windows::ApplicationModel::Core::UnhandledErrorDetectedEventArgs>::{dtor})

   ExceptionCode: c000027b

  ExceptionFlags: 00000001

NumberParameters: 2

   Parameter[0]: 0000003fbc80c8a0

   Parameter[1]: 0000000000000001

0:006> dt -a1 0000003fbc80c8a0 combase!_STOWED_EXCEPTION_INFORMATION_V1*

[0] @ 0000003f`bc80c8a0

---------------------------------------------

0x0000003f`bfc3c5b8

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 80004003

   +0x00c ExceptionForm    : 0y01

   +0x00c ThreadId         : 0y000000000000000000100111001000 (0x9c8)

   +0x010 ExceptionAddress : 0x00007ffb`981e1f1c Void

   +0x018 StackTraceWordSize : 8

   +0x01c StackTraceWords  : 0x18

   +0x020 StackTrace       : 0x0000003f`bd7ac9c0 Void

   +0x010 ErrorText        : 0x00007ffb`981e1f1c  "???"

0:006> !error 80004003

Error code: (HRESULT) 0x80004003 (2147500035) - Invalid pointer

This is a common call stack. A CLR exception is being marshaling to the unhandled error reporting sub-system of WinRT.

0:006> dpS 0x0000003f`bd7ac9c0 L18

00007ffb`98238d27 combase!RoOriginateLanguageException+0x57

00007ffb`71e0f926 mscorlib_ni!DomainNeutralILStubClass.IL_STUB_PInvoke(Int32, System.String, IntPtr)+0xe6

00007ffb`71ff7084 mscorlib_ni!System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.RoOriginateLanguageException(Int32, System.String, IntPtr)+0x44

00007ffb`71ff6b8d mscorlib_ni!System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal.ReportUnhandledError(System.Exception)+0x12d

00007ffb`885042f4 System_Runtime_WindowsRuntime_ni!System.Threading.WinRTSynchronizationContext+Invoker.InvokeCore()+0x73e04

00007ffb`7ee6b915 clr!ExceptionTracker::CallHandler+0xc5

00007ffb`7ee6b80b clr!ExceptionTracker::CallCatchHandler+0x7f

00007ffb`7ee6b728 clr!ProcessCLRException+0x2e6

00007ffb`9a30a7fd ntdll!RtlpExecuteHandlerForUnwind+0xd

00007ffb`9a2b36ba ntdll!RtlUnwindEx+0x366

00007ffb`7ee6d1c0 clr!ClrUnwindEx+0x40

00007ffb`7ee6d174 clr!ProcessCLRException+0x2b2

00007ffb`9a30a77d ntdll!RtlpExecuteHandlerForException+0xd

00007ffb`9a2b29fb ntdll!RtlDispatchException+0x19b

00007ffb`9a2b2668 ntdll!RtlRaiseException+0xf0

00007ffb`976c8384 KERNELBASE!RaiseException+0x68

There is a CLR Last Exception object and the exception code of it matches the record’s code:

0:006> !sos.pe

Exception object: 0000003fa2be4830

Exception type:   System.NullReferenceException

Message:          Object reference not set to an instance of an object.

InnerException:   <none>

StackTrace (generated):

    SP               IP               Function

    0000003FBC80D190 00007FFB1F72FC18 MyBadApp!MyBadApp.Utilities.Authentication.GetAliasFromSecurityToken()+0x18

    0000003FBC80D1D0 00007FFB1F72FAC2 MyBadApp! MyBadApp.MainPage.MainPage_AuthenticateUserCompleted(System.Object, System.EventArgs)+0x82

    0000003FBC80D210 00007FFB1F72F5E5 MyBadApp! MyBadApp.MainPage+<AuthenticateUser_Async>d__0.MoveNext()+0x305

    0000003FBC80EE60 00007FFB724F0B31 mscorlib_ni!System.Runtime.CompilerServices.AsyncMethodBuilderCore.<ThrowAsync>b__4(System.Object)+0x4d61d1

    0000003FBC80EE90 00007FFB88490523 System_Runtime_WindowsRuntime_ni!System.Threading.WinRTSynchronizationContext+Invoker.InvokeCore()+0x33

StackTraceString: <none>

HResult: 80004003

In this case, you can surmise that the System.NullReferenceException exception was thrown within the MyBadApp!MyBadApp.Utilities.Authentication.GetAliasFromSecurityToken() function, and that it was unhandled.

Extraction of the CLR Last Exception object can also sometimes be done in Visual Studio. When you do a Debug with Managed Only on the dump file, the Locals window sometimes contains a pseudo variable called $exception that represents the exception.

The Text Visualizer of the StackTrace member allows you to see the call stack.

Example #2

Looking at another example, we can see that again there is a single record, this time with an "Unspecified error" exception code.

0:004> .exr -1

ExceptionAddress: 73034fec (Windows_UI_Xaml!DirectUI::ErrorHelper::ProcessUnhandledError+0x000000b8)

   ExceptionCode: c000027b

  ExceptionFlags: 00000001

NumberParameters: 2

   Parameter[0]: 0bdaf240

   Parameter[1]: 00000001

0:004> dt -a1 0bdaf240 combase!PSTOWED_EXCEPTION_INFORMATION_V1

[0] @ 0bdaf240

---------------------------------------------

0x0af64034

   +0x000 Header           : _STOWED_EXCEPTION_INFORMATION_HEADER

   +0x008 ResultCode       : 80004005

   +0x00c ExceptionForm    : 0y01

   +0x00c ThreadId         : 0y000000000000000000010010011110 (0x49e)

   +0x010 ExceptionAddress : (null)

   +0x014 StackTraceWordSize : 4

   +0x018 StackTraceWords  : 5

   +0x01c StackTrace       : 0x0af6302c Void

   +0x010 ErrorText        : (null)

0:006> !error 80004005

Error code: (HRESULT) 0x80004005 (2147500037) - Unspecified error

The call stack of the record suggests that this is associated with GetNavigationState:

0:004> dpS 0x0af6302c L5

72ec4e7d Windows_UI_Xaml!DirectUI::NavigationHistory::WritePageStackEntryToString+0x1f7fde

72ec4ef0 Windows_UI_Xaml!DirectUI::NavigationHistory::GetNavigationState+0x1f7ddf

72ccd0fa Windows_UI_Xaml!DirectUI::Frame::GetNavigationStateImpl+0x3a

72cccced Windows_UI_Xaml!DirectUI::FrameGenerated::GetNavigationState+0x2f

737d00eb Windows_UI_Xaml_ni+0x2400eb

But the CLR Last Exception object doesn’t have the same exception code as the record:

0:004> !sos.pe

Exception object: 02cb3cb8

Exception type:   <Unknown>

Message:          <Invalid Object>

InnerException:   System.Runtime.InteropServices.COMException, Use !PrintException e2a09bc6 to see more.

StackTrace (generated):

    SP       IP       Function

    052DF6C0 07141094 MyBadApp!UNKNOWN+0x544

    052DF8A4 73E0D17A mscorlib_ni!System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(System.Threading.Tasks.Task)+0x5e

    052DF8B4 73E0D115 mscorlib_ni!System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(System.Threading.Tasks.Task)+0x35

    052DF8C0 071409DB MyBadApp!UNKNOWN+0xb3

    052DF8CC 7458458F mscorlib_ni!System.Runtime.CompilerServices.AsyncMethodBuilderCore.<ThrowAsync>b__4(System.Object)+0x33

    052DF8D4 6F9EF994 System_Runtime_WindowsRuntime_ni!System.Threading.WinRTSynchronizationContext+Invoker.InvokeCore()+0x24

StackTraceString: <none>

HResult: 80131500

0:006> !error 80131500

Error code: (HRESULT) 0x80131500 (2148734208) - <Unable to get error code text>

It does however have a nested CLR Exception object that does have the same exception code as the record. It too has a call stack that indicates GetNavigationState is having an issue.

0:004> !PrintException /d 02caf968

Exception object: 02caf968

Exception type:   System.Runtime.InteropServices.COMException

Message:          <Invalid Object>

InnerException:   <none>

StackTrace (generated):

    SP       IP       Function

    00000000 00000001 Windows_UI_Xaml_ni!Windows.UI.Xaml.Controls.Frame.GetNavigationState()+0x2

    052DF778 071411B5 MyBadApp!UNKNOWN+0x1d

    052DF788 07140BF3 MyBadApp!UNKNOWN+0xa3

StackTraceString: <none>

HResult: 80004005

Summary

The asynchronous and projected nature of Windows Store applications makes them significantly harder to debug than desktop applications. Knowing the error code and call stack is just the first step in understanding the root cause of a crash in a Store application. Hopefully this blog post has made those first steps easier to undertake, and that those first steps have pointed you in the right direction.

The solutions to some of the more common issues have been talked about on episodes of Channel 9 Defrag Tools. These episodes show the code changes required to avoid the hang or crash:

• Defrag Tools: #67 - Windows 8.1 - Background Task Hang
• Defrag Tools: #68 - Windows 8.1 - HTTP Request Crash
• Defrag Tools: #69 - Windows 8.1 - XML Load Crash
• Defrag Tools: #70 - Windows 8.1 - Interop Crash

I make heavy use of group policy in my home environment.  It makes it very easy to push out defaults to all of my various computers and virtual machines.  However, there are times when I have a setting that I only want applied to virtual machines.  Luckily this is somewhat simple to do.  You need to open the Group Policy Management console and go to the WMI Filters section.

Here you will want to create as many filters as make sense for your environment (as you can see, I have filters that divide my systems into physical and virtual as well as desktop or server).

Once you have created a filter you will want to add the following WMI filter to target virtual machines:

SELECT * FROM Win32_ComputerSystem WHERE Model = "Virtual Machine"

Finally, associate this filter with the group policy that you want applied to virtual machines in your environment.

Some quick notes:

• This will only target Hyper-V virtual machines.  If you are using a different virtualization platform you will need to find out what model string that platform returns.
• To create a group policy that only targets physical computers, just change the ‘=’ to ‘!=’ in the WMI query

Cheers,
Ben

Hopefully you've heard about the upcoming hackathon that Facebook and Microsoft are hosting at the Facebook headquarters in San Francisco on Jan. 17. Head over to the registration page for details and to RSVP for the event.

The goal of the hackathon is to help developers integrate Facebook Login, announced in November of last year, into their Windows and Windows Phone apps.

Facebook Login is an essential part of the fabric of social integration in mobile apps. Developers have been asking for a seamless and officially supported way of integrating the Facebook experience into their Windows and Windows Phone apps. This has been on our radar for a while and started gaining momentum as we entered 2013.

In spring of last year, we approached Facebook with the idea of integrating the Facebook Login into Windows and Windows Phone, with the goal of providing an even greater social experience. Facebook was excited about this, and we started working together on this project. 

From a technology point of view, the problem was challenging due some of the architectural differences between Windows and Windows Phone. For Windows Store applications, the Windows team used the WebAuthenticationBroker to integrate a streamlined authentication process into the OS.

The great thing about WebAuthenticationBroker is that it gives users a consistent way of logging in using any authentication provider. It also enables the secure use of Single Sign On with any Windows Store application via the OAuth open standard. With support from Facebook, getting Facebook Login integrated into this flow was a straightforward effort.

But this technology wasn’t available for Windows Phone 8, so Microsoft and Facebook engineers invented an approach to carry out the authentication using Application Redirects (that is, applications invoke the Facebook app via an app redirect to authenticate the user). After successful authentication, the Facebook app would invoke the original app and return an access token for the user.

To enable this approach, Windows Phone engineers made changes to the Store, introduced elements in the app manifest, and created a callback mechanism — all while keeping a sharp eye on the security model. 

To get the ball rolling on the work, Microsoft’s Windows Phone engineers visited Facebook headquarters last summer and participated in a hackfest with Facebook engineers. Out of that interaction, a barebones proof of concept was produced. As it was further refined over the next few months into Facebook Login, we reached some other important milestones, such as getting the Facebook application into the Windows Store and enhancing the Facebook app on Windows Phone.

In late summer, Facebook engineers visited Microsoft and we all sat down with plenty of coffee and completed the work at a number of hacking sessions that often ran late into the night. With the motto of quick iterations and incremental polish, we crossed the finish line and released the Facebook Login.

Now it is your turn. Come join us for the hackathon at Facebook headquarters. You will get in-person access to both Microsoft and Facebook engineers, learn how to build socially integrated applications for Windows and Windows Phone, and have a chance to win cool prizes . We hope to see you there.

Greetings! Here’s the listing. And here’s a quick snippet from the job description:

“We are looking for a passionate and results-driven content developer to provide book planning and acquisitions, project management, and editorial development for Microsoft Press titles. This is a rare opportunity for an experienced editor who understands Microsoft technology, book acquisitions, and manuscript development. The ideal candidate will have the background and passion to dig deep into technology; proven excellence as an acquisitions or developmental editor; strong instructional design skills; proven capability as a project manager; and ability to combine it all to create market-leading Microsoft Press titles.”

If you’re looking for easy-to-read guidance on how to customize one of the many business process solutions available for download from the Microsoft Dynamics Marketplace, check out the new eBook: Change a business process.

By walking you step-by-step through a visual example, the eBook explains how to use the business process editor to customize an existing business process by adding a stage and steps. This eBook is intended for CRM admins or managers who want to learn how to adapt a business process to match the way their organization does things.

Tras hacer las delicias de los desarrolladores de Windows Phone en otros países, llega a España la campaña de Nokia DVLUP. Si has participado en concursos anteriores como I App You la mecánica de DVLUP te resultará muy familiar.

¿Qué es DVLUP?

DVLUP es un programa de recompensas para desarrolladores de Windows Phone. En él podrás ver el ranking, tanto global, como local, con el número de Apps de cada desarrollador y los badges que tengan. Eso es, puedes ganar badges. Nada más registrarte en DVLUP obtendrás el primer badge, n00b, pero ganarte los otros 51 será mucho más divertido.

Para ganarte tus badges tendrás que ir resolviendo retos. Los retos se añaden de forma periódica y los hay de todos los tipos. Algunos llevarán poco tiempo, por ejemplo añadir una característica específica a tu App, y otros podrán ser carreras de fondo, como logar 100 comentarios o un rating superior a 3,5.

¿Por qué querría hacer los retos?

Porque es un reto. Los retos están diseñados para ser resueltos, para demostrar a los demás que tú puedes, para ganarlos y mostrar tus badges con orgullo. Aun así, si eso no ha resultado suficiente para ti, con cada reto ganaras puntos de experiencia. Además, todos los retos están diseñados para que tu App mejore con nueva funcionalidad, con una interfaz más atractiva o con una mejora de rendimiento.

No podrás comprar badges con experiencia, pero podrás conseguir premios. Desde cursos de formación a sesiones de UX para tu App o promocionarla en la Tienda.

¿Por qué no está X reto? ¿Cuándo estará Y premio?

DVLUP es una comunidad viva. Hoy no hay algo, mañana puede que sí. Ten DVLUP en tus favoritos y no te olvides de echarle un vistazo semanalmente, porque los retos irán cambiando con el tiempo al igual que los premios.

Recuerda que los puntos de experiencia no caducan, así que puedes ir acumulándolos tranquilamente para gastarlos cuando mejor te venga. Así que te animamos a participar en DVLUP y a ganar tus primeros puntos de experiencia.

Un saludo

El equipo de MSDN

As some of you have already noticed, with Dynamics CRM Online2013, we offer a free non-production instance and free storage.  Exciting, isn’t it? If you are not aware of this offering, please read on to learn more about this and how the non-production instance and free storage tie up with your CRM application.

What are non-production instances?

Ok, let’s first begin with what non-production instances are. As the name suggests, non-production instances are add-on instances that are separate from your production instance. They are not the trial instances so they do not expire. All users in your production instances are also users in all your non-production instances, unless you want to restrict the access using a security group.

What are the pricing differences between production and non-production instances?

The pricing model is different for production and non-production instances. Non-productions are cheaper than production instances. At the moment, production instance costs $549 and non-production instance costs $150. This pricing information is subject to change. For the most up to date pricing and licensing information, please refer to the Microsoft Dynamics CRM Online pricing and licensing guide here: http://go.microsoft.com/fwlink/p/?LinkID=313649

How do I restrict access to a CRM instance with security groups?

By default, all of your users in your subscription have access to all your organizations. If you want to restrict which users can access which of your instances, you can do so using the concept of security groups. The following article explains how to control user access to instances using security groups and licenses.

http://msdn.microsoft.com/en-us/library/dn467371.aspx#BKMK_man_sec_group

How can I buy additional instances in CRM online?

If you are a Microsoft Office 365 Global administrator or the Microsoft Office 365 Service administrator, at any time, you can purchase additional CRM Online instance and storage on the Microsoft online services portal Purchase subscriptions page. You must have a Microsoft Office 365 account and a paid Microsoft Dynamics CRM Online Professional user license subscription. Please refer to the following article to learn more about buying additional instances in CRM online:

http://msdn.microsoft.com/en-us/library/dn467371.aspx

When do I get a free non-production instance?

If your CRM subscription includes 25 or more professional USLs (User Subscription Licenses), you will be granted a free non-production instance. Please not that all instances under your subscription, including the free test instance will consume the existing storage that is available to the account.

How do I know I have been granted a free non-production instance?

After you have been granted a free non-production instance, when the Administrator logs into any of instances tied to the subscription, the below message will appear in the application message bar.

Clicking Configure, will take you to the following page where you can configure your newly provisioned non-production instance. You can get also get to the below page directly through this link.

When do I get free storage?

For every increment of 20 professional USLs (User Subscription Licenses), you will be granted 2.5 GB of free storage until your storage capacity reaches 50 GB.

How do I know I have been granted free storage?

If you are granted free storage, when the Administrator logs into any of instances tied to the subscription, the below message will appear in the application message bar.

Clicking “Show Resources”, will take you to the “Resources In Use” page as shown below.

Where can I find how many user licenses I have?

At any time you can find how many user licenses you have from the Microsoft Online Portal: https://portal.microsoftonline.com/License/License.aspx

When I drop my USLs, do I lose the free storage I was granted?

Yes, when your professional USLs (User Subscription Licenses) count drops, you will be losing that piece of extra storage that you do not qualify for anymore.

I am on CRM 2011 online and I have more than 20 or 25 USLs, how can leverage these new offerings?

The simple answer is to Upgrade to CRM 2013 online! Once you upgrade, you will be granted the free additional instance and the free storage if you qualify (depending on your USL count).

Cheers,
Uma Maheswari Anbazhagan
Microsoft Dynamics CRM

Our prior blog posts have focused on the mobile applications that Microsoft is shipping for Dynamics AX 2012.  In addition to those apps, we know there’s a need for developers to build lots of other great apps for AX.   We have captured what we learned in developing our apps, and have shared it with the AX community.  I wanted to remind developers of the information available to them.  These resources apply to phone or tablet apps and across windows, iOS and android platforms. 

Learn about the patterns and approaches used to develop the mobile apps in this whitepaper: Microsoft Dynamics AX 2012 WhitePaper: Developing Mobile Apps

Links to the code samples referenced in the above document

http://code.msdn.microsoft.com/Developing-Secure-Mobile-02105158

http://code.msdn.microsoft.com/Developing-Secure-Mobile-b6ba16a2

Build 2013 session on building the W8 apps for Dynamics AX 2012

http://channel9.msdn.com/Events/Build/2013/2-9193

We’d love to hear about your AX mobile apps (developed or under development) so feel free to comment below.