Kurik's Blog

How to create symbols storage.

noreply@blogger.com (kurikv) — Tue, 26 Apr 2011 18:10:00 +0300

With this post I want to start a series of articles about WinDbg and how to analyze dump files. As you known the secret of effective debugging is using the correct symbols. If you are writing managed code, without symbols debugging is not be possible. Working without symbols over unmanaged code, you may not get clear call stacks - it requires FPO data from the PDB file.

MSDN contains information about how to create symbols server, but there not discuss the most important: how to fill the server characters and binary files. If you want to arrive nirvana you need make next actions.

You should have server with access of any person working on your project. You will probably want to call the server as \\SYMBOLS. :) I will use this mane of server. Create two shared folders titled OSSYMBOLS and PRODUCTSYMBOLS.
Next step - install "Debuging Tools for Windows". After installing Debugging Tools for Windows you should create environment variable _NT_SYMBOL_PATH and assign it the next value:

SRV*\\Symbols\OSSymbols*http://msdl.microsoft.com/download/symbols;
SRV*\\Symbols\ProductSymbols

_NT_SYMBOL_PATH will be indicate WinDBG, where to look for the symbols. In this string we have two symbol servers, separated by semi: one for the symbols of the OS and another for the symbols of your program. SRV letters at the beginning of both parts of the line indicate the debugger to load library SYMSRV.dll and pass it a value placed after the SRV. In the case of the first symbol server you are reporting SYMSRV.DLL, that the symbols OS will be stored in the directory \\Symbols\OSSymbols; after next star is the HTTP address, which SYMSRV.DLL will be used to load any symbols that are absent in the symbol server. This section of the variable _NT_SYMBOL_PATH provides updated symbols of OS. The second part of the variable _NT_SYMBOL_PATH said library SYMSRV.DLL that the specific symbols of your program should be sought only in the shared directory \\Symbols\ProductSymbols. If you want to specify different search paths, you can add them to a _NT_SYMBOL_PATH, separated by semi.
So, the next string indicates that the search for your programs symbols also occurs in the system folder System32:

SRV*\\Symbols\OSSymbols*http://msdl.microsoft.com/download/symbols;
SRV*\\Symbols\ProductSymbols;c:\windows\system32

Symbol server is a database that uses file system to find files. The root directory is called OSSymbols, and all the symbol files, such as ADVAPI32.PDB, located on the first level. Under the name of each file is a directory whose name matches the date/time stamp, signature and other information necessary to definition a specific version of a file. Remember: if you have multiple options file (for example, ADVAPI32.PDB) for different OS versions, you will have a few directories that correspond to each option.
In the next article I will talk about how you can fill your symbol server.

Implementation of the ICommand interface for reuse.

noreply@blogger.com (kurikv) — Mon, 15 Nov 2010 20:13:00 +0200

If you use MVVM (model-view-viewmodel) pattern, the most commonly used mechanism is the binding to action in the View using commands. To assignment the command needed to implement an interface ICommand. It's simple, but it will need to do again and again.

The idea - creating a universal command that takes two delegates: one is called when ICommand.Execute (object param) invoked, the second checks the status of whether you can execute the command (ICommand.CanExecute (object param)).

Requires the method to switching event CanExecuteChanged. It is called from the user interface elements for switching the state CanExecute () command.

public class ModelCommand : ICommand
{
    #region Constructors

    public ModelCommand(Action<object> execute)
        : this(execute, null) { }

    public ModelCommand(Action<object> execute, Predicate<object> canExecute)
    {
        _execute = execute;
        _canExecute = canExecute;
    }

    #endregion

    #region ICommand Members

    public event EventHandler CanExecuteChanged;

    public bool CanExecute(object parameter)
    {
        return _canExecute != null ? _canExecute(parameter) : true;
    }

    public void Execute(object parameter)
    {
        if (_execute != null)
            _execute(parameter);
    }

    public void OnCanExecuteChanged()
    {
        CanExecuteChanged(this, EventArgs.Empty);
    }

    #endregion

    private readonly Action<object> _execute = null;
    private readonly Predicate<object> _canExecute = null;
}

Microsoft Ribbon for WPF

noreply@blogger.com (kurikv) — Wed, 4 Aug 2010 00:02:00 +0300

I am pleased to inform you of the final release of Microsoft Ribbon for WPF. You can download the installer for this release here.

This is great news for Windows developers looking to build rich, fluent user experiences. From the MSDN documentation:

The ribbon is a command bar that organizes the features of an application into a series of tabs at the top of the application window. The ribbon user interface (UI) increases discoverability of features and functions, enables quicker learning of the application, and makes users feel more in control of their experience with the application. The ribbon replaces the traditional menu bar and toolbars.

In short, this control library gives you the ability to incorporate a ribbon user experience in your applications today.

For Windows developers, the ribbon provides a rich experience that you can incorporate quickly and easily for your WPF applications. What’s particularly cool about the Microsoft Ribbon for WPF is that it’s a control library that’s built 100% in pure WPF goodness.

File → New Project...

After downloading and installing the Microsoft Ribbon for WPF, you’ll find the WPF Ribbon Application project template listed for both Visual C# and Visual Basic:

This project template provides you with a very simple example to help get you started:

For a deeper examination of the XAML and control library that’s used to build this application, I strongly recommend that you read Pete Brown’s excellent summary of this release in a post entitled,Announcing: Microsoft Ribbon for WPF. Pete also provides an important point (with emphasis added):

The new ribbon control is compatible with WPF 3.5sp1 and WPF 4. This is a 100% WPF implementation, not a wrapper around native code. That means you get all the great WPF styling capabilities for the new control.

This fact cannot be underscored enough. A true WPF implementation means that you can incorporate styling and rely on assumed WPF functionality (i.e. RibbonButton support the ICommand interface – wahoo!). Having built my fair share of WPF applications in the past – in some cases, wrestling with control interop and styling issues – I love this news.

So, what are you waiting for? Download Microsoft Ribbon for WPF today and start incorporating it into your applications!

Debugging WPF Binding

noreply@blogger.com (kurikv) — Sat, 24 Jul 2010 14:58:00 +0300

WPF implements the mapping of data models using {Binding} expression. However in some cases there may be difficulties with understanding that the value was received as a result of binding. In this article I want to talk about a possible decision to enable the debug mode to see the used values. The solution is not new and probably many about it know, but for those who started working with WPF it might be useful. The essence of solution lies in the fact that the binding is carried out not directly but through a simple converter that does nothing to transform, but allows you to set Breakpoint while debugging and see the value of object that used.

using System; using System.Windows.Data; namespace WpfApplication { public class EmptyConverter : IValueConverter { public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { return value; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { return value; } } }

This is how data binding is implemented to the element. It creates an object converter and used in the {Binding} expression.

<Window x:Class="WpfApplication.TestWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:local="clr-namespace:WpfApplication" x:Name="Window"> <Window.Resources> <local:EmptyConverter x:Key="EmptyConverter"/> </Window.Resources> <Label Content="{Binding Path=TestField, ElementName=Window, Converter={StaticResource EmptyConverter}}" /> </Window>

NullToBoolValueConverter for WPF

noreply@blogger.com (kurikv) — Tue, 13 Jul 2010 23:47:00 +0300

You can enable or disable WPF elements based on if they are null or not. This is not supported, but you can create a simple value converter.

/// <summary> /// Converts null to boolean. /// </summary> /// <remarks> /// If parameter is not specified or specified with null: /// if passed value is null then true is returned, otherwise false. /// If parameter is specified then inversion is done: /// if passed value is null then false is returned, otherwise true. /// </remarks> [ValueConversion(typeof(object), typeof(bool))] public class NullToBoolValueConverter : IValueConverter { public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { bool result = value == null ? true : false; if (parameter != null) return !result; return result; } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { return value; } }

This value converter allows me to bind to any property taking a boolean argument with the following syntax in XAML.

<local:NullToBoolValueConverter x:Key="NullToBoolValueConverter"/> <ComboBox.IsEnabled> <Binding ElementName="TetsComboBox" Path="SelectedItem" Converter="{StaticResource NullToBoolValueConverter}" ConverterParameter="true" /> </ComboBox.IsEnabled>

WPF show or hide element based on CheckBox

noreply@blogger.com (kurikv) — Fri, 2 Apr 2010 19:29:00 +0300

Today I had to do the task for showing or hiding elements based the value of a checkbox. In WinForms 2.0 for this purpose it was necessary to subscribe to event CheckedChanged and in his handler write the code:

private void myCheckBox_CheckedChanged(object sender, EventArgs e)
{
myTextBox.Visible = myCheckBox.Checked;
}

With the new Visibility Enum in WPF, this becomes a bit trickier. To accomplish this, you can use converter BooleanToVisibilityConverter that accept a boolean value and return a visibility value. Now we can cleanly show or hide an element based on a checkbox using just XAML code. The XAML code to use this is below:

<Window

  x:Class="MyTest.XamlOnly"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Title="XamlOnly" Height="300" Width="300">

  <Window.Resources>
    <BooleanToVisibilityConverter x:Key="BoolToVisConverter" />
  </Window.Resources>

  <StackPanel Orientation="Vertical">
    <CheckBox Content="Check to show text box below me" Name="checkViewTextBox"/>
    <TextBox Text="only seen when above checkbox is checked" Visibility="{Binding Path=IsChecked, ElementName=checkViewTextBox, Converter={StaticResource BoolToVisConverter}}"/>
  </StackPanel>

</Window>

Execute Javascript function after updating UpdatePanel

noreply@blogger.com (kurikv) — Tue, 5 Jan 2010 16:12:00 +0200

UpdatePanel is Control of Microsoft ASP.NET AJAX which allows to integrate conveniently enough AJAX into your application. In this article I wish to show as to execute client JavaScript on end of the next updating of this panel. We add EndRequestHandler in request manager:

Sys.WebForms.PageRequestManager.getInstance().add_endRequest(EndRequestHandler);

Here the example of the web form with two TextBox where you enter the text, and a server returns length of the text and displays it in the second TextBox:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head runat="server"> <title></title> <script type="text/javascript"> function EndRequestHandler(sender, args) { if (args.get_error() == undefined) alert("Your text has: " + document.getElementById("txtLength").value + " character(s)"); else alert("There was an error" + args.get_error().message); } function load() { Sys.WebForms.PageRequestManager.getInstance().add_endRequest(EndRequestHandler); } </script> </head> <body onload="load();"> <form id="form1" runat="server"> <asp:ScriptManager ID="_scriptManager" runat="server" /> <asp:UpdatePanel ID="UpdatePanel1" runat="server"> <ContentTemplate> Write something: <asp:TextBox ID="txtData" runat="server" AutoPostBack="true" OnTextChanged="txtDataOnChange" /> <br /> Server says the length is: <asp:TextBox ID="txtLength" runat="server" AutoPostBack="true" /> </ContentTemplate> </asp:UpdatePanel> </form> </body> </html>

Obfuscators for .NET

noreply@blogger.com (kurikv) — Mon, 9 Nov 2009 10:49:00 +0200

From the compiled assemblies (exe and dll) for the platform .NET can easily restore the code to high-level languages (C#, VB.net). This means that your source code can be copied. To protect themselves against such threats, most commercial software developers use various obfuscators.

Why and of who is protected?

Obfuscation as one of the stages is relevant only for the protection of commercial software. Can be used as protection against a variety of industrial espionage. Here all
easy: simply delete the metadata and confuse the rest of the program so that a competitor will be cheaper to write a program from scratch than to disassemble your. Usually for viewing metadata assembly is used .NET Reflector. It has a simple and intuitive interface, as well as the opportunity to expand the functionality of plug-ins. There are also several commercial browsers and assemblies decompiler(trial versions understand only half of the assembly, and "happy owners" licensed version reported is not very large differences from the reflector).

Obfuscators and packers

.NET-applications are trying to protect the two main methods: direct obfuscation IL-code (when the output is almost is valid .Net-assembly, and it can perform on nemodfitsirovannom MS.NET or mono). And the packaging - a modification of the assembly so that the output is obtained winapi-application contains in itself unpacked module and IL-packed code. With obfuscation like everything is clear: given as input. Net assembly, we get the output .Net assembly, it works in much the same. No extra "hidden" data, everything is on the spot, only confused and changed its name to something useless. In the case of a packer, we will face some problems:

Our assembly is now done only under the WIND (or accurately tuned mono + wine)

Packer, who passes the input mscoree original assembly was withdrawn for 1 minute, and it makes no sense for the defense. Packers that intercept the internal function mscoree strongly depend on the version of the framework, and cause some antivirus false positive reaction. Interception of internal functions in general a delicate and thankless.

Packers are native-programs, and do not give compile your application in the x86-64 code, where it is available (and in some cases, this gives a large increase performance)

For the normal execution environment .Net in any case require access to the original IL-bytecode. And even preJITted-assembly should it contain in itself. And this means that to get This bytecode is also realistic.

Quick Reference Guide for PostgreSQL 8.3

noreply@blogger.com (kurikv) — Fri, 6 Nov 2009 15:47:00 +0200

Brief guide to work with PostgreSQL 8.3.
Download in PDF
Download in HTML

Get SPListItem from SPList

noreply@blogger.com (kurikv) — Wed, 14 Oct 2009 10:18:00 +0300

Working with SPList was found that upon receipt of a list item on Guid of SPListItemCollection.this [Guid] took a lot of time on a large collection.
It looked like this:

var uniqId = new Guid(/* get GUID somehow */); SPList list = /* get list somehow */; SPListItem anItem = list.Items[uniqId];* This source code was highlighted with Source Code Highlighter.

But it turns out, there is another way to get a list item SPList.GetItemByUniqueId(Guid uniqueId). Using this method does not arise for the delay in large collections. To determine the differences we use the reflector, and see how to implement a method to obtain an element in the collection for SPListItemCollection in Microsoft.SharePoint.dll. That's what we see in SPListItemCollection.this[Guid]:

public SPListItem this[Guid uniqueId] { get { this.EnsureListItemsData(); this.EnsureFieldMap(); int iIndex = 0; int columnNumber = this.m_mapFields.GetColumnNumber("UniqueId"); string str2 = uniqueId.ToString("B").ToLower(); while (true) { if (iIndex >= this.m_iRowCount) { throw new ArgumentException(); } string str = ((string) this.m_arrItemsData[columnNumber, iIndex]).ToLower(); int num3 = SPUtility.StsBinaryCompareIndexOf(str, ";#"); if ((num3 > 0) && (str.Substring(num3 + 2) == str2)) { this.EnsureListItemIsValid(iIndex); if (this.m_iColection == null) { return new SPListItem(this, iIndex); } return this.m_iColection.ItemFactory(iIndex); } iIndex++; } } }* This source code was highlighted with Source Code Highlighter.

As we can see the contents of the entire collection moves an element by element, each element is calculated with a given match GUID'a. More collection - the longer work.

And now look at the implementation of the method GetItemByUniqueId for SPList:

public SPListItem GetItemByUniqueId(Guid uniqueId) { SPQuery query = new SPQuery(); query.Query = "<Where><Eq><FieldRef Name=\"UniqueId\"></FieldRef><Value Type=\"Guid\">" + uniqueId.ToString("B") + "</Value></Eq></Where>"; query.ViewAttributes = "Scope=\"RecursiveAll\" ModerationType=\"Moderator\""; query.MeetingInstanceId = -2; query.QueryOpt = SPQuery.SPQueryOpt.None | SPQuery.SPQueryOpt.UniqueId; SPListItemCollection items = this.GetItems(query); if (items.Count != 0) { return items[0]; } while (!(this.ID == this.Lists.Web.UserInfoListId)) { throw new ArgumentException(); } throw new ArgumentException(SPResource.GetString("CannotFindUser", new object[0])); }* This source code was highlighted with Source Code Highlighter.

Here, using SPQuery, we obtain directly the very record without sorting the collection.

Conclusion: The use of large lists SPList.Items[Guid] - long, unproductive. Better to use SPList.getItemByUniqueId(Guid);

Using P/Invoke

noreply@blogger.com (kurikv) — Thu, 3 Sep 2009 16:19:00 +0300

I want to show a good example showing the possibility of unmanaged code - we will hide the Start button and Taskbar. For the first time the possibility to use the Windows system functions in their programs, I learned when studying C#. If the C++ call is transparent to the programmer, then for C# is required to declare the desired function. In fact, the example does not have any practical purchase, but the example gives some idea of the organization Windows, and gives a more complete conception of the used functions. Let's start with the theory. First, the Start button, taskbar, system tray, and area of the clock - it is all windows. So, having access to this window, you can change habitual behavior of the interface element. Second - all these windows belong to specified classes. On behalf of the classes can be found descriptors required us windows to do experiments on them. Here are the names of classes:

  Shell_TrayWnd - Taskbar
  Button - Start Button
  TrayNotifyWnd - the notification area with icons and a clock
  TrayClockWClass - Clock

Now on to functions. For our purposes, we need the function FindWindow, FindWindowEx and ShowWindow.

[DllImport("user32.dll")] private static extern IntPtr FindWindow(string ClassName, string WindowName); [DllImport( "user32.dll")] private static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string className, string windowName); [DllImport( "user32.dll")] private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); const int SW_HIDE = 0; const int SW_SHOW = 5; * This source code was highlighted with Source Code Highlighter.

And then everything is easy. With the functions FindWindow and FindWindowEx on behalf of the class are required descriptors, which are then used in the function ShowWindow to hide or show the element.

bool show = false; private void butHideTaskbar_Click(object sender, EventArgs e) { IntPtr taskBarWnd = FindWindow("Shell_TrayWnd", null); IntPtr startWnd = FindWindow(taskBarWnd, IntPtr.Zero, "Button", null); if (startWnd != IntPtr.Zero) ShowWindow(startWnd, show ? SW_SHOW : SW_HIDE); show = !show; } private void butHide_Click(object sender, EventArgs e) { IntPtr taskBarWnd = FindWindow("Shell_TrayWnd", null); IntPtr tray = FindWindowEx(taskBarWnd, IntPtr.Zero, "TrayNotifyWnd", null); IntPtr trayclock = FindWindowEx(tray, IntPtr.Zero, "TrayClockWClass", null); ShowWindow(trayclock, SW_HIDE); } * This source code was highlighted with Source Code Highlighter.

Hook windows messages.

noreply@blogger.com (kurikv) — Wed, 2 Sep 2009 16:15:00 +0300

Today I would like to talk about how in C# you can hook messages that come to the application. For this we use the SetWindowsHookEx function from user32.dll. The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain. You would install a hook procedure to monitor the system for certain types of events. These events are associated either with a specific thread or with all threads in the same desktop as the calling thread. WH_GETMESSAGE installs a hook procedure that monitors messages posted to a message queue.

public static partial class HookManager { private const int WH_GETMESSAGE = 3; private const int WM_KEYDOWN = 0x100; [DllImport( "user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] private static extern int CallNextHookEx(int idHook, int nCode, IntPtr wParam, ref MSG lParam); [DllImport( "user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)] private static extern int SetWindowsHookEx(int idHook, CallbackPtr lpfn, IntPtr hMod, int dwThreadId); [DllImport( "user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)] private static extern int UnhookWindowsHookEx(int idHook); [DllImport( "kernel32.dll")] public static extern int GetCurrentThreadId(); public static void Init() { if (m_hHook != 0) return; m_callBack = new CallbackPtr(CallBack); m_hHook = SetWindowsHookEx(WH_GETMESSAGE, m_callBack, IntPtr.Zero, GetCurrentThreadId()); } public static void Dispose() { if (m_hHook == 0) return; UnhookWindowsHookEx(m_hHook); m_hHook = 0; } private static int CallBack(int code, IntPtr wParam, ref MSG lParam) { if (lParam.msg == WM_KEYDOWN && !m_bInHook) { m_bInHook = true; try { ... } catch (Exception ex) { m_log.Fatal("UNHANDLED!", ex); } finally { m_bInHook = false; } } return CallNextHookEx(m_hHook, code, wParam, ref lParam); } private static CallbackPtr m_callBack; private delegate int CallbackPtr(int code, IntPtr wp, ref MSG lp); private static int m_hHook; private static bool m_bInHook = false; } * This source code was highlighted with Source Code Highlighter.

Google Desktop Actions

noreply@blogger.com (kurikv) — Wed, 30 Jul 2008 01:01:00 +0300

To implement Custom Actions and integrate your application with Google Desktop you will need, in addition to the information in this document:
* Sufficient access to write a plug-in for your application and an installer for it.
* Programming knowledge of the Microsoft Windows Component Object Model (COM).
The Action API consists of a COM interface, which must be exposed by plug-ins wishing to implement custom actions.

[ComVisible(true)] [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] [GuidAttribute("E5A04D23-6921-4ef6-B19B-6C6AA89A46AA")] public interface IGoogleDesktopCustomAction { [DispId(1)] void QueryInterest( [In] Guid location, [In] Guid action, [In, MarshalAs(UnmanagedType.BStr)] string query_string, [In, MarshalAs(UnmanagedType.IUnknown)] object item, [In, Out, MarshalAs(UnmanagedType.BStr)] ref string actionTitle, [Out, MarshalAs(UnmanagedType.BStr)] out string actionCookie, [Out] out ActionHandling handling); [DispId(2)] void HandleAction( [In] Guid location, [In] Guid action, [In, MarshalAs(UnmanagedType.BStr)] string query_string, [In, MarshalAs(UnmanagedType.IUnknown)] object item, [In, MarshalAs(UnmanagedType.BStr)] string action_cookie); }* This source code was highlighted with Source Code Highlighter.

The following sample demonstrates how a component can implement the methods on the IGoogleDesktopCustomAction interface.
QueryInterest is invoked when search results are displayed in browser and HandleAction is invoked when you are opening specific item of search result.

[ComVisible(true)] [GuidAttribute("YOU-GUID")] public class SearchActions : IGoogleDesktopCustomAction { #region IGoogleDesktopCustomAction Members public void HandleAction( Guid location, Guid action, string query, object item, string actionCookie) { try { string uri = ((IGoogleDesktopNotifyEvent)item).GetProperty("uri").ToString(); System.Diagnostics.Process.Start(uri); } catch (COMException ex) { } } public void QueryInterest( Guid location, Guid action, string query, object item, ref string actionTitle, out string actionCookie, out ActionHandling handling) { string extension = uri.Substring(uri.LastIndexOf('.') + 1); if (extension == "txt") handling = ActionHandling.ACTION_HANDLING_OVERRIDE; else handling = ActionHandling.ACTION_HANDLING_DEFAULT; } }* This source code was highlighted with Source Code Highlighter.