Bonafide Ideas

Jan

Microsoft Visual C++ MVP Award for 2013

G’day Community,

Firstly, I’d like to wish you all a happy new year 2013, full of health, blessings & success Smile

Secondly, I’m happy to announce that Microsoft has awarded me with an MVP (9th consecutive year) in the Visual C++ category, therefore I’d like to thank God, my daughter, my wife (for all of her patience & understanding), community & fellow developers,Microsoft and the MVP Program.

I strongly believe in the potential of communities, as well as the opportunity we technical leaders possess to support people by sharing the knowledge and make them more productive, that’s the main reason why I’m passionate about this program. I wish this program and MVPs existed when I was 12 years old, and I spent long hours learning to program in GW-BASIC.

My commitment, as usual is to produce material that you community might find relevant and useful.

Once again thank you all!

Best Regards,

Angel

Nov

Analysing assemblies and finding out possible leaks by not disposing of objects properly

Posted by Angel | Comment: (1)

Category : .NET, Visual C#

Today’s post is about… A command line utility I wrote a few days back for analysing and finding out possible leaks by not disposing of objects properly.

Before we get into the nuts and bolts of the utility, please find attached two files which are:

MSIL Instruction Set Specification (Required to do any MSIL manipulation)
Utility’s Source code

It’s well-known that every single object that implements IDisposable must be disposed by:

Calling the Dispose method explicitly
Enclosing the object that implements IDisposable within an using statement

Said that, let’s have a look at the code snippet shown below

public class LeakyClass {
    public void LeakyMethod() {
        var conn1 = new SqlConnection();
        var conn2 = new SqlConnection();
        conn2.Dispose();
 
        using (var conn3 = new SqlConnection()) {
            // Do something here...
        }
    }
}

This is the generated MSIL from the code snippet

As you can see, three objects of type SqlConnection are created and two of them are disposed. When enclosing the object within an using statement what really happens is that a try… finally… block is produced. As you can see the Dispose method is a callvirt which is a “Call to a virtual method” and it’s virtual because it was implemented from the IDisposable interface. MSIL similar to assembler has some Op codes, actually there are 256 (0×100) Op codes being [Dec = 111 | Hex =0x6f] (callvirt) and this is the one we’ll use in our utility.

The way as our utility works is described as follows:

An assembly is loaded for analysis as specified in argument (eg.: -a "C:\myassembly.dll")

The Inspect method is called which performs the analysis on the modules & types referenced in the assembly

private static void Inspect(Assembly current) {   
 var flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
 var stats = new Dictionary<string, DisposableStats>();
 current.GetModules().ToList().ForEach(x => x.GetTypes().ToList()
    .ForEach(y => y.GetMethods(flags).ToList().ForEach(z => InspectMethod(x, z))));
}

The InspectMethod is called only processing the variables (objects) which implement IDisposable

private static void InspectMethod(Module module, MethodInfo method) { 
  var body = method.GetMethodBody();
 
   if (body != null) {
        var variables = body.LocalVariables;
        var disposable = variables.Where(x => x.LocalType.GetInterfaces()
                         .Where(y => !string.IsNullOrEmpty(y.Name) && 
                                y.Name.Equals("IDisposable")).FirstOrDefault() != null);
  
        var count = disposable.Count();  
        var key = new MethodDescription(method.ReflectedType.ToString(), method.Name);
 
        if (count > 0 && !stats.ContainsKey(key)) 
            stats.Add(key, IdentifyDisposableObjects(body.GetILAsByteArray(), count, module));    
    }
}

Then we call IdentifyDisposableObjects method that takes as an argument an array of bytes containing the MSIL of the method. We take into account only callvirt (0x6F) op code.

private static DisposableStats IdentifyDisposableObjects(byte[] ilasm, int disposable, Module module) { 
    int position = 0, offset = 0, token = 0;
    var retval = new DisposableStats(disposable);
 
    while (position < ilasm.Length) {
        var method = string.Empty;
        var value = ilasm[position++];  
 
        // Is it a callvirt? 
        if (value == 0x6F) {
            offset = position - 1;
            token = ReadInteger(ilasm, ref position);
 
            if ((!string.IsNullOrEmpty(method = module.ResolveMethod(token).Name)) && 
                method.Equals("Dispose", StringComparison.OrdinalIgnoreCase))
                 retval.DisposedCount++;         
        } 
      }  
  return retval;
}

We do this for every method in the assembly, and add this information to a dictionary that’s later dumped as a report.

If you have a copy of reflector, please feel free to check the results of the report with reflector’s disassembly… You’ll be amazed with the amount of objects that are being left behind and not being disposed.

Regards,

Angel

Aug

CyberNanny: Remote Access via Distributed Components

Posted by Angel | Comments: (0)

Category : Kinect, Visual C++, Win32

Tags: Kinect, Visual C++, Windows Azure

This article is about an application called CyberNanny, which I recently wrote to allow me to remotely see my baby daughter Miranda at home from anywhere at any time. It’s written in Visual C++ (MFC) and it comprises different technologies such as Kinect and its SDK, Windows Azure, Web services and Office automation via Outlook. The project is hosted on CodePlex (cybernanny.codeplex.com), where you can check out the code or contribute to it.

Jul

DDD Sydney – Slide deck

Posted by Angel | Comment: (1)

Category : Visual C++, Visual Studio, WinRT

Hi community,

Please feel free to grab the slides I used at DDD Sydney from here

Regards,

Angel

May

Developer… Developer… Developer Sydney!

Posted by Angel | Comments: (0)

Category : Uncategorized

Hi Community,

I would like to invite you all to “Developer… Developer… Developer Sydney”. This event will be held at UTS on Saturday 30th June 2012. I’ll be presenting “Building Windows 8 applications natively with Visual C++”. I look forward to seeing you there.

Best Regards,

Angel

May

CyberNanny is on CodePlex

Posted by Angel | Comments: (0)

Category : .NET, API, C++, COM, GDI+, Kinect, MFC, Visual C++, Win32

Tags: .NET, GDI+, Kinect, MFC, Visual C++, Win32, WWSAPI

Hi Community,

I would like to share with you all the CyberNanny project that I just published on CodePlex. I’ve submitted an article to MSDN magazine about it but I really don’t know when it’s going to be published, so please feel free to download and/or contribute to the project in the meantime. I will let you know when the article is published. The article describes the bits and pieces of the application in depth as well as the technology aspects of it.The image below depicts CyberNanny’s architecture.

Thanks,

Angel

Apr

Taking pictures with Kinect & calling GDI+ to reduce the file size

Posted by Angel | Comments: (0)

Category : C++, COM, GDI+, Kinect, Visual C++, Win32

Tags: C++, COM, GDI+, Kinect, Visual C++

Hi Community,

As mentioned in my previous post, I’ve been putting together an application which comprises technologies like Kinect, Windows Azure & Visual C++. The application name is “CyberNanny” and I wrote it for my beautiful newborn daughter Smile . Actually, I’ve submitted today an article to MSDN magazine about the aforementioned solution.

Today’s post is about how we can take pictures with the Kinect sensor and reduce the size of the resulting image file (for emailing purposes).

Let’s assume that we have a smart pointer of type INuiSensor. INuiSensor is the COM representation of the physical sensor. We also have another smart pointer that holds a reference to a custom class called DrawDevice that performs the drawing via Direct2D and ID2D1Factory

CComPtr<INuiSensor> m_pSensor; 
std::shared_ptr<DrawDevice> m_pDrawColor; 
 
void  Nui_Core::TakePicture(std::shared_ptr<BYTE>& imageBytes, int& bytesCount) { 
    byte *bytes; 
    NUI_IMAGE_FRAME imageFrame; 
    NUI_LOCKED_RECT LockedRect; 
 
    if (SUCCEEDED(m_pSensor->NuiImageStreamGetNextFrame(m_hVideoStream, m_millisecondsToWait, &imageFrame))) { 
        auto pTexture = imageFrame.pFrameTexture; 
        pTexture->LockRect(0, &LockedRect, NULL, 0); 
 
        if (LockedRect.Pitch != 0) { 
            bytes = static_cast<BYTE *>(LockedRect.pBits); 
            m_pDrawColor->Draw(bytes, LockedRect.size); 
        } 
 
        pTexture->UnlockRect(0); 
        imageBytes.reset(new BYTE[LockedRect.size]); 
        memcpy(imageBytes.get(), bytes, LockedRect.size); 
        bytesCount = LockedRect.size; 
        m_pSensor->NuiImageStreamReleaseFrame(m_hVideoStream, &imageFrame ); 
    } 
} 

Please note that we deal with a pointer to byte (array of bytes) and it’s not a safe practice to return a pointer because the memory address might change and our pointer might point to something else, therefore we pass a smart pointer by reference to store the bytes in it.

The code to handcraft our image (picture) which is a BMP is shown below

std::wstring ImageFile::SerializeImage(std::shared_ptr<BYTE>& bytes, int byteCount) { 
    RPC_WSTR guidAsStr; 
    WCHAR tempPath[MAX_PATH]; 
    std::wstring retval, tempFile; 
    std::unique_ptr<GUID> guid(new GUID); 
    CoCreateGuid(guid.get()); 
    UuidToString(guid.get(), &guidAsStr); 
    auto str = std::wstring((LPTSTR) guidAsStr); 
    GetTempPath(MAX_PATH, tempPath); 
    tempFile = std::wstring(tempPath).append(L"photo_").append(str).append(L".bmp"); 
    auto infoHeader = GetBitmapInfoHeader(); 
    auto fileHeader = GetBitmapFileHeader(infoHeader); 
 
    if (SerializeImageHelper(infoHeader, fileHeader, tempFile, bytes, byteCount)) { 
        if (RotateImage(tempFile, retval)) 
            m_savedImagePath = retval; 
    } else retval = L""; 
 
    return retval; 
} 
 
BITMAPINFOHEADER ImageFile::GetBitmapInfoHeader() { 
    BITMAPINFOHEADER retval = {0}; 
 
    retval.biSize = sizeof(BITMAPINFOHEADER); 
    retval.biBitCount = 32; 
    retval.biPlanes = 1; 
    retval.biCompression = BI_RGB; 
    retval.biWidth = 640; 
    retval.biHeight = 480; 
    retval.biSizeImage = ((((retval.biWidth * retval.biBitCount) + 31) & ~31) >> 3) * retval.biHeight; 
 
    return retval; 
} 
 
BITMAPFILEHEADER ImageFile::GetBitmapFileHeader(const BITMAPINFOHEADER& infoHeader) { 
    BITMAPFILEHEADER retval = {0}; 
 
    auto nBitsOffset = sizeof(BITMAPFILEHEADER) + infoHeader.biSize; 
    auto lImageSize = infoHeader.biSizeImage; 
    auto lFileSize = nBitsOffset + lImageSize; 
    retval.bfType = 'B'+('M'<<8); 
    retval.bfOffBits = nBitsOffset; 
    retval.bfSize = lFileSize; 
 
    return retval; 
} 
 
bool ImageFile::SerializeImageHelper(const BITMAPINFOHEADER& infoHeader, const BITMAPFILEHEADER& fileHeader, 
                                     std::wstring& filePath, std::shared_ptr<BYTE>& bytes, int byteCount) { 
    auto retval = false; 
    auto hFile = CreateFile(filePath.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 
 
    if (hFile !=  INVALID_HANDLE_VALUE) { 
        auto newFile = CFile(hFile); 
        newFile.Write(&fileHeader, sizeof(BITMAPFILEHEADER)); 
        newFile.Write(&infoHeader, sizeof(BITMAPINFOHEADER)); 
        newFile.Write(bytes.get(), byteCount); 
        newFile.Close(); 
        retval = true; 
    } 
 
    return retval; 
} 

In order to save our BMP, we must specify two things before serializing the bytes:

Another detail to take into account is, the resulting bitmap is approximately 1.7 MB in size and it’s upside down – This is not very convenient for emailing purposes, so we have to rotate the image 180 degrees and save it with a different format (Encode it), the snippet below shows how we can do this

bool ImageFile::RotateImage(const std::wstring& filePath, std::wstring& newFile) { 
    CLSID jpgClsid; 
    newFile = filePath; 
    auto retval = false; 
    ULONG_PTR gdiplusToken; 
    GdiplusStartupInput gdiplusStartupInput; 
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL); 
 
    if ((retval = GetEncoderClsid(L"image/jpeg", &jpgClsid))) { 
        auto fileToRotate = new Image(filePath.c_str(), FALSE); 
        newFile.replace(newFile.find(L"bmp"), 3, L"jpg"); 
        fileToRotate->RotateFlip(Rotate180FlipNone); 
        fileToRotate->Save(newFile.c_str(), &jpgClsid, NULL); 
        delete fileToRotate; 
    } 
 
    ::DeleteFile(filePath.c_str()); 
 
    GdiplusShutdown(gdiplusToken); 
 
    return retval; 
} 
 
bool ImageFile::GetEncoderClsid(const WCHAR* format, CLSID* pClsid) { 
    UINT  num = 0; 
    UINT  size = 0; 
    auto retval = false; 
 
    ImageCodecInfo* pImageCodecInfo = NULL; 
 
    if ((GetImageEncodersSize(&num, &size)) == Status::Ok && (pImageCodecInfo = (ImageCodecInfo*)(malloc(size))) != NULL) { 
        if (GetImageEncoders(num, size, pImageCodecInfo) == Status::Ok) { 
            for(auto index = 0; index < num; ++index)  { 
                if(wcscmp(pImageCodecInfo[index].MimeType, format) == 0 ) { 
                    *pClsid = pImageCodecInfo[index].Clsid; 
                    free(pImageCodecInfo); 
                    pImageCodecInfo = NULL; 
                    retval = true; 
                    break; 
                } 
            } 
        } 
    } 
 
 
    if (!pImageCodecInfo) 
        free(pImageCodecInfo); 
 
    return retval; 
} 

As you can see, we reduce the file size by saving the image as a JPEG by calling the Save method of the Image class (from 1.7 MB the file size was reduced to 32 KB) and we rotate the image by calling the RotateFlip method of the same class. This functionality is provided by GDI+. It’s important to note that GDI+ needs to be initialized and then shutdown once we’ve finished using it.

Best Regards,

Angel

Mar

Tip of the day–An easy & convenient way to create tabs in an MFC application

Posted by Angel | Comments: (0)

Category : C++, MFC, Visual C++

Tags: C++, MFC, Visual C++

Hi Community,

Today I started to write an MFC application that comprises the Kinect sensor and its SDK, and the idea is to have a single UI with different views, this functionality is provided by the CTabCtrl class (Tab control) – I could’ve accomplish this by creating tabs and setting its properties individually but it’s repetitive code that might grow in the future when a new tab is required, so I came up with a convenient way to do this as shown in the snippet below

void MyKinectAppDlg::CreateTabControl() { 
    auto nIndex = 0; 
    auto tabs = std::map<std::wstring, TCITEM>(); 
    tabs.insert(std::pair<std::wstring, TCITEM>(L"Color View", TCITEM())); 
    tabs.insert(std::pair<std::wstring, TCITEM>(L"Depth View", TCITEM())); 
    tabs.insert(std::pair<std::wstring, TCITEM>(L"Skeletal View", TCITEM())); 
 
    std::for_each(tabs.begin(), tabs.end(), [&] (std::pair<std::wstring, TCITEM> tab) { 
        tab.second.mask = TCIF_TEXT; 
        tab.second.pszText =  (LPWSTR) tab.first.c_str(); 
        m_streamTabs.InsertItem(nIndex++, &tab.second); 
    }); 
} 

and the tab control created is

Happy coding & happy weekend!

Angel

Feb

Implementing Office 365 into our WinRT application with Visual C++ (Part I)

Posted by Angel | Comments: (3)

Category : C++, Microsoft, Office 365, Visual C++, Windows 8 Developer Preview, WinRT

Tags: C++, Office 365, Visual C++, Windows 8 Developer Preview, WinRT

Hi Community,

The following post is about how we can leverage Office 365 (SharePoint in our case) from our WinRT application. WWSAPI will provide the infrastructure required to interact with the Web Services. There’s a blog post I wrote a couple of years ago on WWSAPI that can be found here. The very first thing we have to be aware of is that SharePoint Online relies on Claims-Based authentication which uses FedAuth cookies that are written with an HTTPOnly flag, said that now you must be wondering, how can we retrieve these cookies then?

Before we start delving into the code, I’d like to mention that most of this functionality is encapsulated in a Win32 DLL that’s consumed from our WinRT application. The main reason for this is that WinRT supports only a subset of Win32 and I’d like this functionality to be available to different clients.

Ok… Back to the task of retrieving the FedAuth cookies, we can accomplish this by calling the InternetGetCookieEx function as shown in the ReadSharePointCookies method below, please note two things:

The InternetGetCookieEx function accepts as an argument the type of cookie to retrieve
Our function is an exported function which returns an HRESULT (for success/failure) and it returns a map with all of the HTTPOnly cookies.

SPCLIENT_API HRESULT ReadSharePointCookies(map<basic_string<wchar_t>, basic_string<wchar_t>>& cookies) { 
    auto retval = S_FALSE; 
    DWORD size = CookieBufferLength; 
    unique_ptr<wchar_t> buffer(new wchar_t[size]); 
 
    if (!InternetGetCookieEx(MicrosoftOnlineUrl, NULL, buffer.get(), &size, INTERNET_COOKIE_HTTPONLY, NULL))  { 
        if (size > 0) { 
            buffer.reset(); 
            buffer = unique_ptr<wchar_t>(new wchar_t[size]); 
            if (InternetGetCookieEx(MicrosoftOnlineUrl, NULL, buffer.get(), &size, INTERNET_COOKIE_HTTPONLY, NULL))  { 
                auto cookieStr = basic_string<wchar_t>(buffer.get()); 
                int next = cookieStr.find_first_of(';'); 
 
                while(next != string::npos) { 
                    auto cookie = cookieStr.substr(0, next); 
                    cookieStr = cookieStr.erase(0, cookie.length() + 1); 
                    auto name = cookie.substr(0, cookie.find('=')); 
                    std::remove(name.begin(), name.end(), ' '); 
                    cookies[name] = cookie; 
                    next = cookieStr.find_first_of(';'); 
                } 
 
                retval = S_OK; 
            } 
        } 
    } 
 
    return retval; 
} 

The exported function declaration looks like this

extern "C" 
{ 
    SPCLIENT_API HRESULT ReadSharePointCookies(map<basic_string<wchar_t>, basic_string<wchar_t>>& cookies); 
} 

And we do it to prevent name mangling and preserve compatibility with C. Remember that this is a Win32 DLL consumed from our WinRT application.

For the login process then we leverage/re-use what Office 365 provides us with – A login page

We’re not responsible for the authentication process, but how can we get the cookies after signing in to the site? Well, if you’ve ever used the WebBrowser control (whether it’s WinForms or WPF) then fear not because WinRT provides us with the WebView control, so it’s a pretty straightforward thing to do as shown in the XAML/Code below

<UserControl x:Class="MyMetroSync.Login" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
    mc:Ignorable="d" 
             d:DesignHeight="768" d:DesignWidth="1366"> 
 
    <Grid x:Name="LayoutRoot" Background="#FF0C0C0C"> 
        <WebView x:Name="webContent" Margin="27,31,24,36"  LoadCompleted="webContent_LoadCompleted"  /> 
 
 
    </Grid> 
</UserControl> 

void MyMetroSync::Login::webContent_LoadCompleted(Platform::Object^ sender, Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) 
{ 
    if (e->Uri->Path->Equals(LandingPage)) { 
        App::Properties->Insert(CookieName, ReadSharePointCookie()); 
 
        //Let's call getwebid 
        auto spHelper = ref new Core(); 
        auto result = spHelper->GetWebId(((IMap<String^, String^>^) App::Properties->Lookup(CookieName)), L"http://bonafideideas.sharepoint.com/_vti_bin/webs.asmx"); 
        App::ShowSplit(nullptr); 
    } 
} 

As you can see we got a property bag called Properties to store our cookies and it’s not the same property found in WPF

namespace MyMetroSync 
{ 
    ref class App 
    { 
    private: 
        static Map<String^, Object^>^ properties; 
 
    public: 
        virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ pArgs); 
        static void ShowSplit(Expression::Blend::SampleData::SampleDataSource::SampleDataCollection^ collection); 
        static void ShowLoginPage(); 
 
        static property Map<String^, Object^>^ Properties { 
            Map<String^, Object^>^ get(); 
        } 
    }; 
} 

But hang on… Where do you retrieve the cookies in your application?

typedef HRESULT (*ptrFun) (map<basic_string<wchar_t>, basic_string<wchar_t>>& cookies); 
 
IMap<String^, String^>^ Core::ReadSharePointCookie() { 
    HRESULT result; 
    HINSTANCE hInstance; 
    auto retval = ref new Map<String^, String^>(); 
    auto cookies = map<basic_string<wchar_t>, basic_string<wchar_t>>(); 
 
    if ((hInstance = LoadPackagedLibrary(SP_HELPER_LIBRARY, 0)) != NULL) { 
        auto functor = (ptrFun) GetProcAddress(hInstance, "ReadSharePointCookies"); 
 
        if (functor != nullptr && (functor(cookies)) == S_OK) { 
            for_each(cookies.begin(), cookies.end(), [&] (pair<basic_string<wchar_t>, basic_string<wchar_t>> cookie) { 
                retval->Insert(ref new String(cookie.first.c_str()), ref new String(cookie.second.c_str())); 
            }); 
        } 
 
        FreeLibrary(hInstance); 
    } 
 
    return retval; 
} 

Our Win32 DLL must’ve been added to the solution and since every Metro Style application is “packaged” then the application is able to find it without any issues. Another interesting point is the function LoadPackagedLibrary that’s responsible for loading the specified module and its dependencies into the address space of the calling process, then similarly to how it’s done natively, once we have a HINSTANCE to the loaded module, we call GetProcAddress and its return value is cast into a callback to call the desired function (in this case, ReadSharePointCookies).

See you soon!

Angel

Feb

C++ AMP Specification

Posted by Angel | Comments: (0)

Category : AMP, C++, Microsoft, Visual C++

Tags: AMP, C++, Microsoft

Hi Community,

Microsoft just published the “C++ AMP Specification”, please feel free to download it from here.

Cheers,

Angel

Featured Posts

Search

Microsoft Visual C++ MVP Award for 2013

Analysing assemblies and finding out possible leaks by not disposing of objects properly

CyberNanny: Remote Access via Distributed Components

DDD Sydney – Slide deck

Developer… Developer… Developer Sydney!

CyberNanny is on CodePlex

Taking pictures with Kinect & calling GDI+ to reduce the file size

Tip of the day–An easy & convenient way to create tabs in an MFC application

Implementing Office 365 into our WinRT application with Visual C++ (Part I)

C++ AMP Specification

about.me

Angel Hernandez

Still trying to reinvent the wheel

Angel’s Tweets

Categories

Tags