Powerworkshop C# 4 at BASTA Spring 2011

using System;
using System.Net;
using System.Threading;
using AzureDynamicLoader.Common;
using Microsoft.WindowsAzure.ServiceRuntime;

namespace ADL.Wrk
{
    public class WorkerRole : RoleEntryPoint
    {
        public override void Run()
        {
            // Local helper variables
            var exeAssembly = typeof(Bootstrapper).Assembly.FullName;
            AppDomain subDomain = null;

            #region Setup storage
            var account = CloudStorageHelper.GetCloudStorageAccount();
            
            var tableClient = CloudStorageHelper.GetCloudTableClient(account);
            tableClient.CreateTableIfNotExist(ConfigurationCache.Current.LogTableName);
            var logContext = tableClient.GetDataServiceContext();

            var queueClient = CloudStorageHelper.GetCloudQueueClient(account);
            var enablerQueue = queueClient.GetQueueReference(ConfigurationCache.Current.EnablerQueueName);
            enablerQueue.CreateIfNotExist();
            var disablerQueue = queueClient.GetQueueReference(ConfigurationCache.Current.DisablerQueueName);
            disablerQueue.CreateIfNotExist();
            #endregion

            while (true)
            {
                try
                {
                    if (subDomain == null)
                    {
                        #region Wait for enabler message
                        var enableMsg = enablerQueue.GetMessage();
                        if (enableMsg != null)
                        {
                            var assemblyName = enableMsg.AsString;
                            enablerQueue.DeleteMessage(enableMsg);

                            subDomain = AppDomain.CreateDomain(
                                "Subdomain",
                                null,
                                new AppDomainSetup() { ApplicationBase = System.Environment.CurrentDirectory });
                            var bootstrapper = (Bootstrapper)subDomain.CreateInstanceAndUnwrap(
                                exeAssembly,
                                typeof(Bootstrapper).FullName);
                            if (!bootstrapper.TryStartup(assemblyName))
                            {
                                AppDomain.Unload(subDomain);
                                subDomain = null;
                            }
                        }
                        #endregion
                    }
                    else
                    {
                        #region Wait for disabler message
                        var disableMsg = disablerQueue.GetMessage();
                        if (disableMsg != null)
                        {
                            disablerQueue.DeleteMessage(disableMsg);
                            try
                            {
                                AppDomain.Unload(subDomain);
                            }
                            finally
                            {
                                subDomain = null;
                            }
                        }
                        #endregion
                    }

                    Thread.Sleep(10000);
                }
                catch (Exception ex)
                {
                    CloudStorageHelper.WriteLog(logContext, ex);
                }
            }
        }

        public override bool OnStart()
        {
            // Set the maximum number of concurrent connections 
            ServicePointManager.DefaultConnectionLimit = 12;

            // For information on handling configuration changes
            // see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.

            return base.OnStart();
        }
    }
}

using System;
using System.Collections.Concurrent;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using AzureDynamicLoader.Common;

namespace ADL.Wrk
{
    internal class Bootstrapper : MarshalByRefObject
    {
        public bool TryStartup(string assemblyName)
        {
            var account = CloudStorageHelper.GetCloudStorageAccount();
            var logContext = CloudStorageHelper.GetCloudTableClient(account).GetDataServiceContext();

            try
            {
                // Check if assembly name also contains a type name
                var typeName = string.Empty;
                if (assemblyName.Contains(';'))
                {
                    var nameParts = assemblyName.Split(';');
                    assemblyName = nameParts[0];
                    typeName = nameParts[1];
                }

                // Get assembly from blob store
                CloudStorageHelper.WriteLog(logContext, string.Format("Trying to load {0} from blob store", assemblyName));
                var blobClient = CloudStorageHelper.GetCloudBlobClient(account);
                var assemblyBlob = blobClient
                    .GetContainerReference(ConfigurationCache.Current.ContainerName)
                    .GetBlobReference(assemblyName);
                var binaryAssembly = assemblyBlob.DownloadByteArray();

                // Load assembly needed for geo operations (SQL Server Feature Pack)
                Assembly.LoadFile(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Microsoft.SqlServer.Types.dll"));
                Assembly.Load(typeof(IObserver<,>).Assembly.FullName);
                Assembly.Load(typeof(ObservableExtensions).Assembly.FullName);
                Assembly.Load(typeof(EnumerableEx).Assembly.FullName);
                var assembly = Assembly.Load(binaryAssembly);

                // Look for startup type (has to implement IStartup)
                CloudStorageHelper.WriteLog(logContext, "Looking for type in dynamically loaded assembly");
                var startupType = assembly.GetTypes().Where(t => (typeName.Length == 0 || t.Name == typeName) && typeof(IStartup).IsAssignableFrom(t)).FirstOrDefault();
                if (startupType != null)
                {
                    CloudStorageHelper.WriteLog(logContext, string.Format("Found type {0}", startupType.FullName));

                    // Setup logging queue
                    var logQueue = new BlockingCollection<string>(5000);
                    Task.Factory.StartNew(() =>
                        {
                            foreach (var logItem in logQueue.GetConsumingEnumerable())
                            {
                                CloudStorageHelper.WriteLog(logContext, logItem);
                            }
                        });

                    // Create instance of startup type and start Run method in a separate thread
                    var startupObject = Activator.CreateInstance(startupType) as IStartup;
                    CloudStorageHelper.WriteLog(logContext, "Starting dynamically loaded component async.");
                    Task.Factory.StartNew(() =>
                        {
                            try
                            {
                                startupObject.Run(
                                    s => logQueue.Add(s),
                                    ex => logQueue.Add(CloudStorageHelper.GetExceptionText(ex)));
                            }
                            catch (Exception ex)
                            {
                                CloudStorageHelper.WriteLog(CloudStorageHelper.GetCloudTableClient().GetDataServiceContext(), ex);
                            }
                        });
                    CloudStorageHelper.WriteLog(logContext, "Launched dynamically loaded component async.");

                    // Return true to indicate that worker thread has been started successfully
                    return true;
                }
                else
                {
                    CloudStorageHelper.WriteLog(logContext, "Did not find a type that implements IStartup");
                }
            }
            catch (Exception ex)
            {
                CloudStorageHelper.WriteLog(logContext, ex);
            }

            // Return false to indicate that there has been an error
            return false;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq.Expressions;

namespace DynamicPropertyBag
{
    public class PropertyBag : IDynamicMetaObjectProvider
    {
        private Dictionary<string, dynamic> values = new Dictionary<string, dynamic>();

        public PropertyBag()
        {
        }

        protected PropertyBag(IEnumerable<KeyValuePair<object, object>> properties)
            : this()
        {
            foreach (var prop in properties)
            {
                this.SetMember(prop.Key.ToString(), prop.Value);
            }
        }

        public dynamic GetMember(string name)
        {
            return this.values[name];
        }

        public void SetMember(string name, dynamic value)
        {
            this.values[name] = value;
        }

        public DynamicMetaObject GetMetaObject(Expression parameter)
        {
            return new DynamicGetSetMetaObject<PropertyBag>(this, parameter);
        }

        private class DynamicGetSetMetaObject<T> : System.Dynamic.DynamicMetaObject
        {
            public DynamicGetSetMetaObject(T v, Expression e)
                : base(e, BindingRestrictions.Empty, v)
            {
            }

            public override DynamicMetaObject BindGetMember(GetMemberBinder info)
            {
                var x = this.Expression;
                var test = Expression.TypeIs(x, typeof(T));
                var target = Expression.Call(
                                  Expression.Convert(x, typeof(T)),
                                  typeof(T).GetMethod("GetMember"),
                                  Expression.Constant(info.Name));
                return new System.Dynamic.DynamicMetaObject(target, BindingRestrictions.GetExpressionRestriction(test));
            }

            public override DynamicMetaObject BindSetMember(SetMemberBinder info, DynamicMetaObject value)
            {
                var expression = Expression.TypeIs(this.Expression, typeof(T));
                var target = Expression.Block(
                    Expression.Call(
                        Expression.Convert(this.Expression, typeof(T)),
                        typeof(T).GetMethod("SetMember"),
                        Expression.Constant(info.Name),
                        Expression.Convert(value.Expression, typeof(object))),
                    Expression.Convert(value.Expression, typeof(object)));
                return new System.Dynamic.DynamicMetaObject(target, BindingRestrictions.GetExpressionRestriction(expression));
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            dynamic myObj = new PropertyBag();
            myObj.FirstName = "Rainer";
            myObj.LastName = "Stropek";

            Console.WriteLine(myObj.LastName);
        }
    }
}