Dimitar Kapitanov's blog

Getting Started with ADO.NET Data Services and Telerik Open Access – Step IV

Dimitar Kapitanov — Tue, 16 Dec 2008 11:59:32 GMT

Just a quick follow-up: we uploaded the application sample as a code library item named "Using OpenAccess with SilverLight and Ado.Net Data Services"

and it is available at: http://www.telerik.com/community/code-library/orm/general/using-openaccess-with-silverlight-and-ado-net-data-services.aspx

Getting Started with ADO.NET Data Services and Telerik Open Access – Step III

Dimitar Kapitanov — Tue, 16 Dec 2008 09:14:17 GMT

After we prepared our data service it is time to put some client UI into it. I must apologize in advance as the only UI that I’ve used is a ListBox control, and it looks… well pretty much ugly. The goal was to proof that the whole setup works as expected, not to design a profound UI solution. I am pretty sure that as a follow up, our SilverLight team will enhance the sample to a full-scale integration example very soon.

To start with, add a SilverLight application in your solution:

In the process of adding you will have to setup where the SilverLight will be hosted:

This is also doable from the settings of the web project: invoke the context menu on your web site project then go to Property Pages > SilverLight Applications > New… and add/setup the SilverLight project.

After we successfully have made the setup, we can start enhancing our SilverLight application.

The first thing to notice is inside the code-behind class generated for the data service. It includes two classes named :

public partial class OADataContext : global::System.Data.Services.Client.DataServiceContext

and

public partial class Product

The first class implements the client-side data context (you can name it a proxy if you want) that is the entry point for the service. The Product class is the entity that is being handled by the service.

To be able to track changes to the entities that are processed in the SilverLight we have to implement the INotifyPropertyChanged interface for the Product entity. It is not implemented by default; my guess is because that way the code is not polluted with an enormous set of auto-generated overrides or partial implementations. We can do so in a partial class. Just add a class file named ProductPartial.cs, and inside define the partial class like:

public partial class Product : INotifyPropertyChanged

What we have generated inside the Product class are properties like:

/// <summary>
 /// There are no comments for Property ProductName in the schema.
 /// </summary>
 public string ProductName
 {
     get
     {
         return this._ProductName;
     }
     set
     {
         this.OnProductNameChanging(value);
         this._ProductName = value;
         this.OnProductNameChanged();
     }
 }
 private string _ProductName;

The basic pattern is to not allow overrides of the properties, but rather implement partial methods that have their signatures generated for example OnProductIDChanging(value) and OnProductIDChanged() that are called prior to and after setting the field value. We are interested only in the event that gets fired after the value is changed, so we will override for example the OnProductNameChanged method so that it will fire the change notification event:

partial void OnProductNameChanged()
{
    FirePropertyChanged("ProductName");
}

/// <summary>
/// Fires the property changed.
/// </summary>
/// <param name="propertyName">Name of the property.</param>
void FirePropertyChanged(string propertyName)
{
    if (PropertyChanged != null)
    {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

We iterate the operation for all Product properties that we know will be changed, and we require the change to be persisted on the server. Actually there is a lot of “data plumbing” code to be written in SilverLight, but I am sure the guys at Microsoft will address this issue pretty soon.

So after we implemented the missing part of our Product entity, lets see how the actual UI is bind and behaves. What I have put on the page is a simple ListBox that shows the products and two buttons – the first one changes the ProductName property of the first product in the list, and the second one pushes the change back to the server.

The definition of the listbox is the bare minimum to show data:

XAML

<ListBox x:Name="listBox1"
    HorizontalAlignment="Stretch" 
    Grid.RowSpan="1" 
    Grid.Row="0" VerticalAlignment="Stretch" 
    ItemsSource="{Binding Mode=OneWay}"  >

    <ListBox.ItemTemplate>
        <DataTemplate>
            <StackPanel x:Name="DisplayListData"
             Orientation="Horizontal"
             VerticalAlignment="Bottom" 
             Margin="5" >
                <TextBlock x:Name="ProductID"
                 Text="{Binding ProductID}"
                 Margin="5,0,0,0" 
                 VerticalAlignment="Bottom"
                 HorizontalAlignment="Left"
                 FontSize="12">
                </TextBlock>

                <TextBlock x:Name="ProductName"
                 Text="{Binding ProductName}"
                 Margin="5,0,0,0" 
                 VerticalAlignment="Bottom"
                 HorizontalAlignment="Left"
                 FontSize="12">
                </TextBlock>

                <TextBlock x:Name="UnitPrice"
                 Text="{Binding UnitPrice}"
                 Margin="5,0,0,0" 
                 VerticalAlignment="Bottom"
                 HorizontalAlignment="Left"
                 FontSize="12">
                </TextBlock>
            </StackPanel>
        </DataTemplate>
    </ListBox.ItemTemplate>
</ListBox>

and the two buttons:

XAML

<Button x:Name="Push" Grid.Row="1">
    <TextBlock x:Name="BProductName"
                 Text="Change object named {Binding ProductName} to ModifiedXXX"
                 Margin="5,0,0,0" 
                 VerticalAlignment="Bottom"
                 HorizontalAlignment="Left"
                 FontSize="12">
    </TextBlock>
</Button>
<Button x:Name="Save" Grid.Row="2">
    <TextBlock x:Name="SaveText"
                 Text="Save Changes to the server using ADS."
                 Margin="5,0,0,0" 
                 VerticalAlignment="Bottom"
                 HorizontalAlignment="Left"
                 FontSize="12">
    </TextBlock>
</Button>

The first thing that we do inside the code-behind is to initialize the data service context in the constructor:

public Page()
{
    InitializeComponent();

    // Create the Service class specifying the location of the ADO.NET Data Services 
    context = 
      new OADataContext(new Uri("OADataService.svc", UriKind.Relative));

    // We use the Async pattern (BeginExecute/EndExecute) everywhere because oft the disconnected nature of
    // the application.
    context.BeginExecute<Product>(new Uri("Products", UriKind.Relative), loadProductsCallback, context);
}

What you really have to understand is that we always use asynchronous way of working with data in SilverLight, because of the nature of the data services that we use. The real job is done in the callback method that gets executed when the service logic finishes processing the communication part:

private void loadProductsCallback(IAsyncResult asyncResult)
{
    DataServiceContext ctx =
        asyncResult.AsyncState as DataServiceContext;

    this.products = ctx.EndExecute<Product>(asyncResult).ToList();

    foreach (Product product in products)
    {
        // Wireup Change Notification
        product.PropertyChanged +=
          new PropertyChangedEventHandler(product_PropertyChanged);
    }
    this.listBox1.DataContext = products; // ctx.EndExecute<Product>(asyncResult);
    this.Push.Click += new RoutedEventHandler(Push_Click);
    this.Save.Click += new RoutedEventHandler(Save_Click);
}

The most important part was the logic that wires the PropertyChanged event of every entity to be tracked down (pretty messy isn't it?). The logic that gets executed updates the state of the entity inside the service's data context:

void product_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
    Product product = (Product)sender;
    context.UpdateObject(product);
}

Also in the callback we prepare a list out of the query, set the list as a data provider to the listbox's DataContext property, wire the buttons events and are ready to roll.

How about pushing the changes back to the server? Well it is pretty straight-forward too - we initiate an asynchronous operation again, and provide a callback that implements the real operation:

void Save_Click(object sender, RoutedEventArgs e)
{
    context.BeginSaveChanges(SaveChangesOptions.ContinueOnError,
                                new AsyncCallback(OnSaveAllComplete),
                                null);
}

and here is the callback:

void OnSaveAllComplete(IAsyncResult result)
{
    bool succeeded = true;
    try
    {
        DataServiceResponse response =
          (DataServiceResponse)context.EndSaveChanges(result);

        foreach (OperationResponse opResponse in response)
        {
            if (opResponse.Error != null)
            {
                succeeded = false;
            }
        }

    }
    catch (Exception ex)
    {
        succeeded = false;
    }

    // Alert the User
}

Well that was all of it - no fancy stuff, but what we accomplished so far is great: we pushed data back and forth through an Ado.Net DataService, we had a SQL database that was handled through OpenAccess on the server side, and on the client-side we had a SilverLight application as a front-end. Stay tuned as I expect that the SilverLight team will cook a real case and way more slick (in terms of UI) example for all of us.

Enjoy!

Getting Started with ADO.NET Data Services and Telerik Open Access – Step II

Dimitar Kapitanov — Mon, 15 Dec 2008 10:20:48 GMT

In my previous post we looked into providing data to the client using ADO.NET Data Services and Telerik OpenAccess. However it is very rare just to present data, as usually some processing is done by the application on the client side, data gets modified and it is pushed back to the server for persistence. With ADO.NET Data Services this is done by implementing the IUpdateable interface by the data context class used on the server.

NOTE: We do not implement IExpandProvider at the moment.

They say that a picture is worth a thousand words, so same is true for the code – I just present you the code required for updates:

#region IUpdatable Members

public object CreateResource(string containerName, string fullTypeName)
{
    Type t = Type.GetType(fullTypeName);
    Debug.Assert(t != null);  // assume can find type
    object resource = Activator.CreateInstance(t);
    Scope.Add(resource);
    return resource;
}

public object GetResource(IQueryable query, string fullTypeName)
{
    object resource = null;

    foreach (object o in query)
    {
        if (resource != null)
        {
            throw new Exception("Expected a single response");
        }
        resource = o;
    }

    if (resource == null)
        return new Exceptions.NoSuchObjectException("Object cannot be found.", null);

    if (fullTypeName != null && resource.GetType() != Type.GetType(fullTypeName))
        throw new Exception("Unexpected type for resource");

    return resource;
}

public object ResetResource(object resource)
{
    Debug.Assert(resource != null);
    Scope.Refresh(resource);
    return resource;
}

public void SetValue(object targetResource, string propertyName, object propertyValue)
{
    PropertyInfo pi = targetResource.GetType().GetProperty(propertyName);
    if (pi == null)
        throw new Exception("Can't find property");
    pi.SetValue(targetResource, propertyValue, null);
}

public object GetValue(object targetResource, string propertyName)
{
    PropertyInfo pi = targetResource.GetType().GetProperty(propertyName);
    if (pi == null)
        throw new Exception("Can't find property");
    return pi.GetValue(targetResource, null);
}

public void SetReference(object targetResource, string propertyName, object propertyValue)
{
    SetValue(targetResource, propertyName, propertyValue);
}

public void AddReferenceToCollection(object targetResource, string propertyName, object resourceToBeAdded)
{
    PropertyInfo pi = targetResource.GetType().GetProperty(propertyName);
    if (pi == null)
        throw new Exception("Can't find property");
    IList collection = (IList)pi.GetValue(targetResource, null);
    collection.Add(resourceToBeAdded);
}

public void RemoveReferenceFromCollection(object targetResource, string propertyName, object resourceToBeRemoved)
{
    PropertyInfo pi = targetResource.GetType().GetProperty(propertyName);
    if (pi == null)
        throw new Exception("Can't find property");
    IList collection = (IList)pi.GetValue(targetResource, null);
    collection.Remove(resourceToBeRemoved);
}

public void DeleteResource(object targetResource)
{
    Scope.Remove(targetResource);
}

public void SaveChanges()
{
    Scope.Transaction.Commit();
}

public object ResolveResource(object resource)
{
    Scope.Retrieve(resource); return resource;
}

public void ClearChanges()
{
    Scope.Transaction.Rollback();
}

#endregion

Yes, this is just what you need to accomplish to have updates pushed back to the server in this example.

To see the service up and running make your web site the startup site and just hit F5. This will start the test web server and the service. Then open a browser and navigate to the service: "http://localhost:<port>/OADataServices/OADataService.svc"

Basically this is all about the server part of the application. In the next post I will guide you how to create extremely simple SilverLight test application that interacts with the provided service. Also I will try to implement the whole sample application in VB.NET as there is strong demand for that. Enjoy!

Getting Started with ADO.NET Data Services and Telerik Open Access - The First step

Dimitar Kapitanov — Fri, 12 Dec 2008 07:14:43 GMT

To my opinion the day the Astoria incubation project was unveiled, all about querying and pushing data through a webservice changed for good. I was pretty amazed to see that the REST paradigm was so easily embraced in the .NET world. Now some time later, this is an official release and it is called ADO.NET Data Services. For all of you that are not familiar with ADO.NET Data Services you can find more information here.

To put it shortly: <quote>“The goal of the ADO.Net Data Services framework is to facilitate the creation of flexible data services that are naturally integrated with the web, using URIs to point to pieces of data and simple, well-known formats to represent that data, such as JSON and plain XML.”</quote>.

In other words it gives a lightweight, though robust HTTP communication layer above the data sources, that serves remote parts of the application, for example a SilverLight or ASP.NET UI front-ends.

Natively ADS supports only EntityFramework, but they do provide also LINQ support. Having LINQ in the game means that we could query almost any data provider underneath – including Telerik Open Access ORM tool. Yes, that’s right because we support LINQ and IQueryable we are able to provide ADS support as well.

To start we have to create a web site first that will host our data service. This is pretty much straight forward as you probably know:

After creating the site we add a ADO.NET Data Service item named OADataService.svc:

Note: If you have installed .NET SP1 you should have the ADO.NET Data Service template in your “Add New Item” dialog.

After that you will end up with a code file inside your App_Code folder like this:

public class WebDataService : DataService< /* TODO: put your data source class name here */ >
{
    // This method is called only once to initialize service-wide policies.
    public static void InitializeService(IDataServiceConfiguration config)
    {
        // TODO: set rules to indicate which entity sets and service operations are visible, updatable, etc.
        // Examples:
        // config.SetEntitySetAccessRule("MyEntityset", EntitySetRights.AllRead);
        // config.SetServiceOperationAccessRule("MyServiceOperation", ServiceOperationRights.All);
    }
}

We will modify the file contents (it is not compilable even at the beginning), but first we have to build our data model.

To do so add a library project to the solution. The library project will host our data model and that way we will have a better separation of concerns.

After we have the library project in the solution we have to build our model using the Open Access tool. For the purpose of this example we will add only the Products table inside our model.

To do so first enable the project to use Open Access. You can do so by starting the wizard from two places in Visual Studio:

1. Main menu > OpenAccess > “Enable Project to use ORM…”

2. Invoking the context menu on the library project (named Model for the purpose of this example), then go to OpenAccess > Enable Project

The wizard will guide you through few steps and we are ready to roll:

After the project gets “Open Access enhanced” we can start the Reverse Mapping wizard (Main Menu > OpenAccess > Reverse Mapping (Table to Classes)) and have the Products entities generated:

The wizard will guide you through the whole procedure and eventually will generate the Product entity file that looks like:

public partial class Product
{
    int productID;
    //The 'no-args' constructor required by OpenAccess. 
    public Product()
    {
    }

    [Telerik.OpenAccess.FieldAlias("productID")]
    public int ProductID
    {
        get { return productID; }
        set { this.productID = value; }
    }

.
}

After we generated the entities we have to provide a data context implementation for our OADataService data service. Add a class named OADataContext.cs in your Model project.

What do we need inside the class to provide all resources needed for the data service? Actually the ADS team allowed us to have quite broad implementation of the class: What we really need are properties that implement the IQueryable interface thus exposing the underlying data in a standard way to the ADS communications stack above. So for the Products entities we put a property like:

public IQueryable<Product> Products
{
    get
    {
        return this.scope.Extent<Product>();
    }
}

The scope variable is actually an instance of IObjectScope – Open Access implements the actual data context through this interface. So to start providing data we need a couple of lines of code and they look like:

/// <summary>
/// Summary description for OADataContext
/// </summary>
public partial class OADataContext : IDisposable
{
    // Fields
    IObjectScope scope = null;

    public OADataContext()
    {
        this.scope = this.ProvideScope();
    }

    public OADataContext(IObjectScope scope)
    {
        this.scope = scope;
    }

    public virtual IObjectScope Scope
    {
        get
        {
            if (this.scope == null)
            {
                // Attempt to get the Scope
                this.scope = this.ProvideScope();
            }
            return this.scope;
        }
    }

    public IQueryable<Product> Products
    {
        get
        {
            return this.scope.Extent<Product>();
        }
    }

    protected virtual IObjectScope ProvideScope()
    {
        IObjectScope scope = ObjectScopeProvider1.GetNewObjectScope();
        scope.TransactionProperties.AutomaticBegin = true;
        return scope;
    }
    #region IDisposable Members

    public void Dispose()
    {
        if (scope != null)
        {
            scope.Dispose();
            scope = null;
        }
    }
    #endregion
}

Then we have to update the file we generated for our OADataService (it generates with compilation errors, and I believe they did it on purpose :) )

Having a data context means that we will modify the OADataService file like this:

[System.ServiceModel.ServiceBehavior(IncludeExceptionDetailInFaults = true)]
public class OADataService : DataService<OADataContext>
{
    protected override void HandleException(HandleExceptionArgs args)
    {
        base.HandleException(args);
    }

    // This method is called only once to initialize service-wide policies.
    //We overide it to enable all CRUD operations by setting EntitySetRights.All
    public static void InitializeService(IDataServiceConfiguration config)
    {
        config.SetEntitySetAccessRule("*", EntitySetRights.All);
    }
}

You should note the following:

- You have to refer the Model project from the web site or you will not be able to access the OADataContext type.

- The WCF attribute [System.ServiceModel.ServiceBehavior(IncludeExceptionDetailInFaults = true)] is very helpful when troubleshooting the service – without it you will not be able to gather enough information about the errors that may arise.

- the OADataContext source code is already distributed with the product installer as of version 2008.3 1205.

In the next post I will guide you how not only to feed data to the client, but also to implement all CRUD operations on the server based on Open Access O/R tool.

Enjoy!

Enabling Asp.net development on Vista 64

Dimitar Kapitanov — Fri, 12 Dec 2008 04:42:16 GMT

Well as I figured it out it was not a complicated thing, but there are some specifics of course:

Installing IIS

By default IIS7 is included in the distribution (I use the Enterprise edition of Windows Vista), but is not installed by default. To do so open ControlPanel > Programs and Features.

On the right side of the window click the "Turn Windows features on or off" link and a dialog will open:

Installing required features

You can select and check the Internet Information Services feature. By default not everything required gets selected. You have to check also the Internet Information Services>World Wide Web Services>Security> Windows Authentication and Internet Information Services>World Wide Web Services>Application Development Features> ASP.NET

This is pretty much all that you have to do to be able to run an asp.net site for example. Enjoy!

The Object Relational “Impedance Mismatch”

kapitanov — Wed, 08 Oct 2008 07:39:47 GMT

Now I know that most of you are familiar with this “as old as the world” problem, so to ease the uprising tension I will not go into the theoretical and architectural kind of stuff. Rather I want to remind to all of us why the (O)bject (R)elational mapping software domain exists nowadays.

In general there are few major obstacles to overcome when designing an efficient N-Tier application. The persistence storage of a modern application is usually a RDBMS. These kinds of systems store information in a highly efficient way and allow fast retrieval, information queries and scalability, and all that because of the normalization theory and Edgar F. Codd. In a typical database you have tables, which consist of columns and rows. The columns represent the schema of the data, whereas the rows contain the real information bound to the particular schema. The tables are bound in so called relations that represent the dependencies amongst the different data sets.

On the other side, majority of the applications are developed using OOD and OOP approaches. In the OOP world you just don’t have strict “schemas” and normalization process, the data is described by using different types, and of course, by using object references (which is different than relations).

So you have two completely different worlds, not just as programming paradigms, but also completely alien in terms of technology approaches. The interrelations between both models are crucial for the application’s stability, performance, and scalability, but suffer because of the following differences:

- Encapsulation – in OOP every class has internal and private implementation that is contained and maintained by the class instance. The external entities do not have access to this “reserved” part of the class instance – it is accessible in a manner to guarantee the class invariant behavior. The public methods should define the “contract” with the outside world. The goals are to have a set of rules that guarantee the valid state of the object instance throughout its lifecycle.
Opposite to that the RDBMS use of public data, which must be amenable to upgrade, inspection and queries. Significantly fewer constraints are applied on the data that represent object characteristics, for example there are no formal “private” and “public” fields that are embedded in the RDBMS technology platforms.

- Data type differences – no pointer/reference data types are allowed in the relational systems. Even more, there are substantial differences between the scalar data types in both OOP and RDBMS models, which cause translation/mapping difficulties.

- Structure and integrity – in OOP it is considered normal to have highly nested structures (objects containing sets of different objects recursively, thus producing quite complicated object graphs). This poses difficulties in translating these structures to relational schemas, where all data is represented in a named set of global, flat relation variables. Also most of the constraints in the relational models are declaratively defined, whereas in the OOP systems this is mostly implemented as verification procedures that rise exceptions and/or implement error handling.

- Manipulating the model – maybe the biggest difference of all is the way we “handle” both models. The relational models have a formalized and well defined set of operators and primitives to query and handle data. The OOP models, on the opposite, use lower level, case and technology specific access, and imperative operations.

- Transactions – a well defined, mission-critical part of the RDBMS systems are the transactions that encapsulate the smallest unit of work performed by RDBMS. Their scope is larger and even not typical for any OO generic system at present. In OO systems at present mostly field-scope or property-scope changes are tracked in transaction mechanisms, which is not even near to what database transactions are capable of. Transaction and consistency are only ensured for changes of primitive typed fields at most in OO systems. In general, no isolation mechanisms are used as well.

So, enough said on what are the real approaches to solving the impedance mismatch problem in object-relational models mapping. There is no complete or universal solution to this, but there are two approaches to solving it: through compensation and through minimization (the second approach is less popular). Minimization generally refers to building object-oriented database systems or having extensions to the programming languages that incorporate the relational models into the OO world (example: transitional memory paradigm). The compensation is typically done trough intermediate frameworks that tend to map the data model entities to the ones used in the OO systems. Such “translation” layers are generally referred to as O/R mappers. Of course there is always the possibility to “cook” something yourself, but personally I prefer using mature and widely used frameworks, whether free or commercial.

Generally they do have a few technical aspects that are used to accomplish their target goals. The most widely used approach is the code generation, where based on some entities model, real code is generated in the project. The code in the form of classes implements the entities from the data model in an OO manner that is easy and simplistic to use in imperative OO languages. Because of its OO nature, the classes encapsulate all the logic that is required to interact correctly with the O/R mapping framework.

So how to solve the O/R impedance mismatch in practice? What frameworks are there on the market? Should you use an Open Source or a commercial vendor product? Maybe just use a code generator with DAL templates instead?

Well, I will be going through all of these questions and lot more in a series of articles that I am starting on the O/R mapping domain.

The journey begins with evaluating general purpose code generation techniques that use templates to generate Data Access Layers. Then I will go through presenting some of the most popular O/R tools on the market. After a short assessment, every O/R tool will be demonstrated in a simple example that includes our RadGridView for Windows Forms control, and possibly RadChart. In the course of doing it, I will present the special features, i.e. the “bells and whistles” of the O/R mappers and our UI components. Then the final verdict on O/R mappers will be issued – the tool that will be used to prepare a real life application based on patterns and best practices…

And understandable styled using our UI components (I will start with Windows Forms, but if there is enough interest, will continue with ASP.NET AJAX, WPF, Silverlight, you name it). I will be experimenting with IoC frameworks on top of the O/R mapping as well.

Wrapping a .NET user control as an ActiveX

kapitanov — Wed, 17 Sep 2008 13:34:37 GMT

Before even asking why one should do anything like this, let me clarify that this is a good technique to spice up a bit your VB6 application. Now I know this is not cutting edge but still it is important to a lot of people (as I found out already).

So let’s start then...

Create a new solution that includes a Windows Forms application (to test easily the functionality provided by the user control). Then add a library project that will wrap our user control.

What is demonstrated by this example is a very simple example that includes a label, and a button inside of a user control. When the button is clicked, the code in the Click eventhandler changes the text content of the label.

The library

Open Property Settings window, select the Application tab (if not active). You should see an “Assembly Information…” button – click on it and it will open a dialog form with various assembly settings.

You will see a checkbox named “Make assembly COM-visible”. The checkbox must be checked.

Application Settings Tab

Also you will see a GUID field – it is used to set the ID of the typelib if this project is exposed to COM.

If you want automatic registration of the freshly created ActiveX wrapper you should check the “Register for COM interop” checkbox in the Build tab of the settings form.

Build Settings

As far as I know the only thing it does is actually to run Regasm.exe after every build to register the types with COM (which you probably shouldn't do until you're stable because your COM GUIDs will change whenever you change the methods unless you specify GUIDs explicitly, so your registry could end up with a lot of registration junk for versions that will never be used).

If you're using VB.NET, you also need a strong named assembly. But it is considered a good practice so I’ve done it even in the C# project.

Sign Settings

This is all you have to do in the project settings, but we have unfinished business with the code base as well.

[ProgId("ActiveXTestLibrary.UserControl")]
[ClassInterface(ClassInterfaceType.AutoDispatch)]
public partial class UserControl1 : UserControl
{

}

What we have here is the ProgId attribute which provides a unique name for the created ActiveX interface. It is uniquely identified by the assembly GUID, yet the GUIDs are not human-readable, and a second level of abstraction (easy referral) is provided by the (Programmatic IDentifier) or the ProgId attribute. For example, the ProgID for the Word automation object is Word.Basic.

The second ClassInterface attribute states whether and how an COM interface will be generated for the managed assembly. The behavior is controlled through an enum named ClassInterfaceType. You can find more on the topic here: http://msdn.microsoft.com/en-us/library/system.runtime.interopservices.classinterfacetype.aspx

Last but not least you can provide static methods that are invoked when the ActiveX is registered or unregistered through the Regasm.exe:

[ComRegisterFunction()]
public static void RegisterClass(string key)
{
    StringBuilder sb = new StringBuilder(key);
    sb.Replace(@"HKEY_CLASSES_ROOT\", "");

    // Open the CLSID\{guid} key for write access

    RegistryKey k = Registry.ClassesRoot.OpenSubKey(sb.ToString(), true);

    RegistryKey ctrl = k.CreateSubKey("Control");
    ctrl.Close();

    // Next create the CodeBase entry - needed if not string named and GACced.

    RegistryKey inprocServer32 = k.OpenSubKey("InprocServer32", true);
    inprocServer32.SetValue("CodeBase", Assembly.GetExecutingAssembly().CodeBase);
    inprocServer32.Close();

    k.Close();
}

[ComUnregisterFunction()]
public static void UnregisterClass(string key)
{
    StringBuilder sb = new StringBuilder(key);
    sb.Replace(@"HKEY_CLASSES_ROOT\", "");

    // Open HKCR\CLSID\{guid} for write access

    RegistryKey k = Registry.ClassesRoot.OpenSubKey(sb.ToString(), true);

    // Delete the 'Control' key, but don't throw an exception if it does not exist
    if (k == null)
    {
        return;
    }
    k.DeleteSubKey("Control", false);

    // Next open up InprocServer32

    RegistryKey inprocServer32 = k.OpenSubKey("InprocServer32", true);

    // And delete the CodeBase key, again not throwing if missing 

    inprocServer32.DeleteSubKey("CodeBase", false);

    // Finally close the main key 

    inprocServer32.Close();

    k.Close(); 
}

The methods have predefined names (RegisterClass and UnregisterClass) and should be marked respectively with the ComRegisterFunction/ ComUnregisterFunction attributes. Here in this example we register the category of the ActiveX as a UI control.

Testing the ActiveX control

You can do so by using the tstcon32.exe (ActiveXControlTestContainer) that is provided with your Visual Studio installation. You can invoke it easily through the Visual Studio Command Prompt which has all variables and paths preset correctly.

Unlocking locked assemblies

You can end up with locked assemblies due to the tstcon32 test. What you can do is use file unlock utility to kill the locking process. Then you could unregister the COM interface using the Regasm.exe /unregister option and then delete the file.

Visual Studio Tooltips unplugged: How to use multiple monitors with Visual Studio efficiently.

kapitanov — Tue, 16 Sep 2008 05:57:33 GMT

It is no urban legend that having more monitors results in greater productivity, and most of all tremendous increase in developer’s comfort. Even the Myth Busters (http://en.wikipedia.org/wiki/MythBusters) dudes know that.

So imagine that your group’s budget allows installing a brand new (say 22 inches) TFT display as your second, or even better you already have the setup.

What are your options with VS 2005/2008 for efficient management of the screen estate to bust productivity?

Better code access

You can vertically split the Visual Studio screen estate in two, and position the divider down the center of the two monitors. This can be done using the command Window (main menu)> New Vertical Tab Group. You can position the properties window in the second screen also.

Debugging on the second monitor

On the primary monitor you can have your application running, while on the second you can position (docked or undocked) the debugging windows like the Watch windows, Output, Breakpoints windows, etc.

Using effectively help and documentation

You can put the help viewer or the MSDN on your second monitor and use it in parallel with your main activity.

*You can save the layout of the windows by using the wizard: Tools (main menu) > Import / Export Settings.

*remember that there are two layout to setup: in debugging and in standard mode

Visual Studio Tooltips unplugged: Drag and Drop code artifacts to Toolbox General Tab.

kapitanov — Fri, 12 Sep 2008 05:59:15 GMT

I bet you never thought about this feature! Me either…

It’s good that there is a marvelous blog about all goodies in VS maintained by a nice lady.

I will be monitoring and making comments on the topics there that have excited me most.

So what is on today’s menu? As you’ve probably figured it out already, I will comment on a fine (but unknown to me) feature of dragging and pasting code artifacts straight to the VS toolbox. At first I was a little bit skeptic, but it really worked out, let me show you how:

1. Mark a code segment in the code editor

2. Drag the selected code to the General Tab of the Toolbox

3. You will end up with a toolbox item that represents the code snippet.

4. Drag back to the code editor, or double click to insert at the cursors position.

Yes, that was it really :) All worked as expected.

You said Windows 3.11? Did I hear right?

kapitanov — Thu, 11 Sep 2008 06:42:51 GMT

Well folks that's right - MS Windows for Workgroups 3.11 is pretty much still alive and kicking. First when I found out that this 15+ years old OS was still popular in the embedded segment (please forgive my ignorance as embedded systems are not my core competency) I couldn't believe my eyes. According to John Coyne this fact changes starting October 1st, 2008 - from this date on OEM's will no longer be able to license Windows for Workgroups 3.11.
The comments and the flame that started at ArsTechnica are very interesting though. It looks like the guys that develop embedded applications really loved that OS. I wonder whether Windows Vista will still have place in our hearts 15 years from now. What is your opinion? Share it with the Telerik community :)

PDC approaching

kapitanov — Wed, 10 Sep 2008 06:24:04 GMT

Ever wondered what technologies MS has up its sleeve for the closest future?
I bet you've heard at least words like Live Mesh, Office Communications Server, SQL Server 2008, FAST, Silverlight, Oslo, Visual Studio Team System, Virtualization, SharePoint, Dynamics, XNA.
You didn't? So maybe you know about ASP.NET or perhaps IronRubby?
The technologies that I've mentioned will make it into the spotlight at PDC 2008 event. You can check out details on 50 of more than 200 sessions that will be presented at PDC.

PNDs, UMPCs, MIDs – what’s it all about?

Dimitar Kapitanov — Thu, 26 Jun 2008 09:22:06 GMT

Let me clarify first that the title is a bit misleading. You may think that the story will comment on these devices in general, but you are wrong :). I will comment NVidia’s* entry in the handheld and portable devices business in particular, and what it means for the whole industry. Will they shape the landscape the way they did in the GPU market? Why is this event important enough to compel a guy that develops software to blog about hardware? Why the Nvidia Tegra? Why not the IPhone 3G? Or the HTC Diamond? A lot of tough questions to answer and I will try my best to give you a reasonable answer.

PNDs, UMPCs, MIDs – the common issues

Whether it is a PND (Personal Navigation Device), MID (Mobile Internet Device) or UMPC (Ultra-Mobile PC) or any other fancy acronym, the key goal of these devices is MOBILITY. One should be able to connect from various places, using various carriers, based on different technologies such as WiFi/Max, GPRS and 3G. Furthermore, it should feature positioning , and be able to use geospatial data based on GPS , Galileo or GLONASS, accept and broadcast live HD video.

UI intensive applications demand a powerful CPU, while being truly mobile relies on low energy consumption. Sadly, these two qualities are mutually exclusive – the higher the frequency and the intensity of calculations processed by the CPU, the higher the amount of charge drained from the energy source. Furthermore, as we all know, advances in battery technology does not follow Moore's law, so ultra-compact and über-powerful energy sources are not expected anytime soon. This leaves us to attack the problem from the opposite end: to conserve as much energy as possible. For this purpose, a number of energy saving techniques have been developed, but frankly speaking, ALL of them have a negative impact on CPU performance. Well that’s the tradeoff folks, as they say, there is no such thing as a free lunch. Reducing the power consumption and extending the operational state of the device, comes with lower CPU productivity, and ultimately results in a less vibrant user experience and sluggish graphics. It might even render some applications virtually unacceptable for MIDs (e.g. high-end medical applications).

So, what’s so special about the Tegra device, and can it deliver? Why not a ü(ber)Phone?

Don’t get me wrong about all the *Phones – they are marvelous devices, a huge leap in UX, but they still are today’s technology, while here the story goes about what comes tomorrow. An important difference is that the NVidia Tegra is a SoC (System on a Chip) while the IPhone, or the HTC Diamond for example are consumer devices. Still, keep in mind that consumer products are built on chipsets and CPUs. By highlighting this new technology the good guys and gals at NVidia brought to us, I am lifting the curtain and revealing to you what the next generation mobile devices will most probably look like.

Their architecture is ARM based, which gives a complete energy saving technology stack far better than the one the x86 architecture has to offer (even in its Atom incarnation). Furthermore, the ARM processor core provides Virtual Machine optimized instructions and a SIMD instruction set that is most suitable for multimedia applications. All of this, combined with NVidia’s low-micron fabrication process, it makes for a significant advantage.

You can see a sample of how NVIDIA Tegra packs more punch for less consumed power (or so they claim). What really amazed me is the demo UI interface that NVidia calls RayGun Navigator (any resemblance with a game?) which clearly demonstrates the GPU capabilities (HD video, smooth animations, physics effects such as particles, optical effects). In additional, you can have a full flavored 3D rendering.

Well, so much for the info that has publicly been released so far. Nevertheless, expect more, as I will be monitoring this technology closely and will be posting updates here.

* The names of actual companies and products mentioned herein may be the trademarks of their respective owners.

New hardware surfacing from Redmond

Dimitar Kapitanov — Thu, 31 May 2007 12:02:00 GMT

It went public at 12:01 a.m. on May 30 – Microsoft® revealed the outcome of "Project Milan" now branded as Microsoft Surface™ and scheduled to debut in November this year. The nature of the project is a "multi-touch, gestural- and object-recognition interface technology on which Microsoft has been laboring for the past few years".

Named "Surface" and five years in the making, it's set to establish a paradigm of what Microsoft calls "surface computers" which use touch as the sole method of input. The goal is to deliver a hardware/software platform very close to the people and to weave the technology into the texture of everyday life. What is about to happen is clearly demonstrated by Jeff Han in his talk about the genius of multi-touch interface design. The interest in this bleeding edge technology is very strong all around the industry as most of the major players believe it will bring a whole new way of using software/hardware technology to the market. In this quest the Redmond giant is not alone as hardware makers like Hewlett-Packard and Philips have publicly and independently (a brief demonstration of Philips Entertaible concept) demonstrated their own approaches to delivering surface-computing and gesture-recognition. Eon Reality, the 3D and virtual-reality software vendor which licensed Microsoft’s Touchlight technology last year, offers a product called Eon Touchlight. As it is obvious that advanced UI interfaces require advanced hardware (not only for the presentation part but also for the human interaction interface)

more and more products from different vendors that are based on surface computing paradigm will emerge into the market. I believe introducing such hardware is part of the strategy at Redmond to bring the technology closer to the people, to make it far easier to use it and create content, even software for non-it specialists. On the software front it combines with recent MS presentation technology both for Windows (WPF) and the Internet which allows the development of a very rich presentation layer not by developers, but by the people that understand UX most. It is obvious that the Surface™ product line will be marketed as consumer electronics products where Microsoft delivers all the software artifacts and services, a question is rising whether the company is becoming more and more "hardware oriented". While presenting a whole pile of new game consoles, media players keyboards and mice the officials answer to this question is "NO". We will be monitoring the development of surface computing further.

Origami: the next Big Small thing.

Dimitar Kapitanov — Thu, 20 Apr 2006 18:34:00 GMT

Will Microsoft take on Apple and Palm with its all-in-one consumer/business ultra-portable device?

Well, you’ve probably heard the news already - Microsoft is entering the persona-portble-cool-weired-widgets market with their own device… The device code named Origami (official name is UMPC which is spelled out like Ultra Mobile PC) is very compact all-in-one information device that is targeted as an iPod, Palm and BlackBerry competition. Origami sounds way cooler than UMPC though (I keep asking myself why the guys at MS are giving great code names like Indigo, Avalon and Origami, and the official naming is almost unpronounceable like WPF, WCF, UMPC, etc. ), so I’ll be mostly using the code name here. So where is the Origami project being developed? In MS research labs or in the marketing department? It looks like both are true:

Microsoft hides neither its iPod envy nor its lack of satisfaction with the Portable Media Center devices its partners have been producing. And no one from Redmond has denied reports that Microsoft has plans to get into the business of building its own family of iPod killers.

But I’ am betting Microsoft won't classify Origami devices as an MP3 player... Instead, Microsoft will convince its wizards in the market-research business to create a whole new category of all-in-one mobile communicators (better than Sidekicks; more comprehensive than Treos; able to leap even BlackBerries in a single bound!)

What's your take? Is it time for Apple, Palm and others to get some fresh competition? And is Microsoft the right company to deliver an all-in-one soaped-up device of this sort? Or are we way off-base in our educated guess that Origami will morph into a family of OrPods (OrigamiPods)?

By the way they have few (to be more precise three) flash introductory commercials. They are very stylish and I got involved from the moment I saw them, take a look… Commercial One, Commercial Two and Commercial Three…

For those of you who already got hooked up, Microsoft announced a real deal contest, the winners are getting a bundle of Origami devices produced by Samsung and a Slingbox™ by SlingMedia. The only thing you have to do is write an essay (no more than 250 words!) and being a legal resident of the 50 United States, and District of Columbia.

To recap, the device known as Origami/Haiku has a bright and interesting future as this article at the Seattle News clearly shows, so we will monitor closely the activities there. Expect nothing less than turning the mobile devices market upside-down when a player like Microsoft creates a new market niche with a high-tech device like Origami. And by the way the Origami team got a nice blog where you can read very interesting things, like the History of Origami by Otto (five parts for now).

Creating a simple code snippet in Visual Studio 2005 – Part II

Dimitar Kapitanov — Tue, 21 Mar 2006 10:24:00 GMT

Hi All,
This is the second installment of the series "Code snippets in Visual Studio 2005". Well it has been quite a while since I updated my blog. My apologies, I think we all got too wrapped up in developing our new products and preparation of Q1 2006 release to remember to keep writing. However now I (having the time) intend to do just that.

So creating a code snippet is a relatively easy task, however I will make a real case to demonstrate the creation process (refresh your mind on the topic here):

- First create a text file (with your preferred editor, mine is Notepad) with a .snippet extension.

- Now open the saved text file (it will be actually an XML file) and after careful review of the Code Snippets Schema Reference ( http://msdn2.microsoft.com/en-us/library/ms171418.aspx ), we are ready to proceed further.

The file must provide a valid XML schema in the first line so we will begin by declaring:

<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
[ code snippet content here]
</CodeSnippets>

Inside the CodeSnippets section we declare the snippet container as follows:

<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
   <CodeSnippet Format="1.0.0">
     [ code snippet content here]
   </CodeSnippet>
</CodeSnippets>

Then we proceed by declaring a header section

<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
<Header>
<Title>Telerik sample snippet</Title>
<Shortcut>ItemCommand</Shortcut>
</Header>
[ code snippet content here]
</CodeSnippet>
</CodeSnippets>

* The shortcut element is used for easier insertion of the code snippet – type
"ItemCommand" and press Tab to insert the code snippet in a VB.NET project, or press Tab twice if in C# project.

And the real code snippet goes to the Snippet section:

<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>Telerik sample snippet</Title>
        </Header>
    <Snippet>
    <References>
        <Reference>
            <Assembly>System.Windows.Forms.dll</Assembly>
        </Reference>
    </References>
    <Code Language="VB">
        <![CDATA[MessageBox.Show("Hello World")]]>
    </Code>
    </Snippet>
    </CodeSnippet>
</CodeSnippets>

There you can implement References section (only Visual Basic supports this section)

<Snippet>
<References>
<Reference>
<Assembly>System.Xml.dll</Assembly>
</Reference>
</References>
<Code Language=" CSharp">
</Code>
</Snippet>

…the Imports section which is very useful if one wants to include commonly used namespaces, say Telerik.WebControls, Telerik.WebControls.UI:

<Snippet>
    <Imports>
        <Import>
            <Namespace>Telerik.WebControls</Namespace>
        </Import>
        <Import>
            <Namespace> Telerik.WebControls.UI</Namespace>
        </Import>
    </Imports>
    <Code Language=" CSharp">
    </Code>
</Snippet>

* There must be exactly one Namespace element in an Import element

... and Code section ( in a specified language supported by the CLR). I will use code for a common scenario regarding the usage of Custom Item Commands in our r.a.d.grid component:

<Snippet>
    <Imports>
        <Import>
            <Namespace>Telerik.WebControls</Namespace>
        </Import>
        <Import>
            <Namespace> Telerik.WebControls.UI</Namespace>
        </Import>
    </Imports>
    <Code Language=" CSharp">
    <![CDATA[

    protected void RadGrid1_ItemCommand(object source, Telerik.WebControls.GridCommandEventArgs e)
    {
        if (e.CommandName == "EditSelected")
        {
            if (RadGrid1.SelectedIndexes.Count == 0)
            {
                return;
            }
            foreach (GridDataItem item in RadGrid1.SelectedItems)
            {
                item.Edit = true;
            }
            e.Item.OwnerTableView.Rebind();
            return;
        }
        if (e.CommandName == "UpdateEdited")
        {
            if (RadGrid1.EditIndexes.Count == 0)
            {
                return;
            }

            foreach (GridDataItem item in RadGrid1.EditItems)
            {
                RadGrid1.MasterTableView.PerformUpdate(item, true);
            }
            e.Item.OwnerTableView.Rebind();
            return;
        }

        if (e.CommandName == "DeleteSelected")
        {
            if (RadGrid1.SelectedIndexes.Count == 0)
            {
                return;
            }

            foreach (GridDataItem item in RadGrid1.SelectedItems)
            {
                e.Item.OwnerTableView.PerformDelete(item, true);
            }
            e.Item.OwnerTableView.Rebind();
            return;
        }

(Supported languages are VB, CSharp, VJSharp, and XML). Also all snippet code must be placed between <![CDATA[ and ]]> brackets.

So finally here is the complete code:

<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
    <Header>
        <Title>Telerik sample snippet</Title>
    </Header>
<Snippet>
    <Imports>
        <Import>
            <Namespace>Telerik.WebControls</Namespace>
        </Import>
        <Import>
            <Namespace> Telerik.WebControls.UI</Namespace>
        </Import>
    </Imports>
    <Code Language=" CSharp">
    <![CDATA[

        if (e.CommandName == "DeleteSelected")
        {
            if (RadGrid1.SelectedIndexes.Count == 0)
            {
                return;
            }

        if (e.CommandName == "CancelAll")
        {
            foreach (GridDataItem item in RadGrid1.EditItems)
            {
                item.Edit = false;
            }
            e.Item.OwnerTableView.IsItemInserted = false;
            e.Item.OwnerTableView.Rebind();
            return;
        }
    }
    ]]>
    </Code>
</Snippet>
</CodeSnippet>
</CodeSnippets>

Additional reading:
http://msdn2.microsoft.com/en-us/library/ms165396.aspx

http://msdn2.microsoft.com/en-us/library/wy5tazc9.aspx