void Initialize_NoLock() {
			try {
				if (initCounter++ != 0) {
					Debug.Fail("Initialize() called recursively");
					return;
				}

				if (parameterList == null)
					parameterList = new ParameterList(this, ownerType);

				declaringType2 = ownerType;
				InitNameAndAttributes_NoLock();
				InitRVA_NoLock();
				InitCustomAttributes_NoLock();
				InitDeclSecurities_NoLock();
				InitGenericParams_NoLock();
				InitSignature_NoLock();
				Debug.Assert(CanFreeMethodBody, "Can't free method body");
				FreeMethodBody();
				InitParamDefs_NoLock();
				ResetImplMap();
				semAttrs = 0;
				overrides = null;
				this.parameterList.UpdateParameterTypes();
				canFreeMethodBody = !ownerType.CompletelyLoaded;
			}
			finally {
				initCounter--;
			}
		}

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            object valueA = parameters.GetParameter<object>("ValueA");
            object valueB = parameters.GetParameter<object>("ValueB");

            return valueA.Equals(valueB);
        }

		public override object Execute(ParameterList parameters, FunctionContextContainer context)
		{
			var result = new List<FormEmail>();
			result.AddRange(parameters.GetParameter<IEnumerable<FormEmail>>("EmailA"));
			result.AddRange(parameters.GetParameter<IEnumerable<FormEmail>>("EmailB"));
			return result;
		}

        public override ISource Create(Uri uri, string pageData)
        {
            string userHref = uri.Host;
            string username = userHref.Split('.')[0];

            string title = pageData.GetStringBetween("<title>", "</title>").Trim();
            string currentPageStr = pageData.GetStringBetween("<span id=\"pagination_current_page\"", ">", "<");
            string totalPagesStr = pageData.GetStringBetween("<span id=\"pagination_total_pages\"", ">", "<");

            string pagingUrl = pageData.GetStringBetween("<div class=\"view_pages_page\"", " href=\"", "\"");
            string pagingUrlFormat = Regex.Replace(pagingUrl, @"page=\d+", "page={0}");

            ParameterList parameters = new ParameterList();
            parameters.AddValue(VideoChannelSourceCreator.UserParameterName, username);
            parameters.AddValue(VideoChannelSourceCreator.UserHrefParameterName, userHref);
            parameters.AddValue(VideoChannelSourceCreator.TitleParameterName, title);
            parameters.AddValue(CurrentPageParameterName, int.Parse(currentPageStr));
            parameters.AddValue(TotalPagesParameterName, int.Parse(totalPagesStr));
            parameters.AddValue(PagingUrlFormatParameterName, pagingUrlFormat);

            BlipVideoChannelSource channelSource = new BlipVideoChannelSource(uri, this, parameters);

            var downloadSources = ParseDownloadSources(pageData, channelSource);
            foreach (var downloadSource in downloadSources)
                channelSource.Add(downloadSource);

            return channelSource;
        }

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            var metaTags = new List<XElement>();

            string contentType = parameters.GetParameter<string>("ContentType");
            string designer = parameters.GetParameter<string>("Designer");
            bool showGenerator = parameters.GetParameter<bool>("ShowGenerator");

            if (!string.IsNullOrWhiteSpace(contentType))
            {
                metaTags.Add(new XElement(Namespaces.Xhtml + "meta",
                    new XAttribute("http-equiv", "Content-Type"),
                    new XAttribute("content", contentType)));
            }

            if (!string.IsNullOrWhiteSpace(designer))
            {
                metaTags.Add(new XElement(Namespaces.Xhtml + "meta",
                    new XAttribute("name", "Designer"),
                    new XAttribute("content", designer)));
            }

            if (showGenerator)
            {
                metaTags.Add(new XElement(Namespaces.Xhtml + "meta",
                    new XAttribute("name", "Generator"),
                    new XAttribute("content", "Composite C1 CMS - Free Open Source from http://composite.net/")));
            }

            return metaTags;
        }

        public override XElement GetWidgetMarkup(ParameterList parameters, string label, HelpDefinition help, string bindingSourceName)
        {
            XElement widgetMarkup = base.BuildBasicWidgetMarkup("DataReferenceSelector", "Selected", label, help, bindingSourceName);
            widgetMarkup.Add(new XElement("DataReferenceSelector.DataType", typeof(IMediaFileFolder).AssemblyQualifiedName));

            return widgetMarkup;
        }

        public Data(EntityId readerId, EntityId writerId, long seqNum, ParameterList inlineQosParams, SerializedPayload payload)
            : base(SubMessageKind.DATA)
        {
            this.readerId = readerId;
            this.writerId = writerId;
            this.writerSN = new SequenceNumber(seqNum);

            if (inlineQosParams != null && inlineQosParams.Value.Count > 0)
            {
                Header.FlagsValue |= 0x2;
                this.inlineQosParams = inlineQosParams;
            }

            if (payload.ContainsData())
            {
                Header.FlagsValue |= Flags.DataFlag; // dataFlag
            }
            else
            {
                Header.FlagsValue |= Flags.KeyFlag; // keyFlag
            }


            this.serializedPayload = payload;
        }

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            IComparable valueA = parameters.GetParameter<IComparable>("ValueA");
            IComparable valueB = parameters.GetParameter<IComparable>("ValueB");

            return valueA.CompareTo(valueB);
        }

		public MethodResponse(string content)
		{
			this.Parameters = new ParameterList();
			LoadOptions options = LoadOptions.None;
			XDocument xDocument = XDocument.Parse(content, options);
			XElement root = xDocument.Root;
			XElement xElement = root.Element("fault");
			if (xElement != null)
			{
				Fault fault = Fault.ParseXml(xElement);
				string message = string.Format("XMLRPC FAULT [{0}]: \"{1}\"", fault.FaultCode, fault.FaultString);
				throw new XmlRPCException(message)
				{
					Fault = fault
				};
			}
			XElement element = root.GetElement("params");
			List<XElement> list = element.Elements("param").ToList<XElement>();
			foreach (XElement current in list)
			{
				XElement element2 = current.GetElement("value");
				Value value = Value.ParseXml(element2);
				this.Parameters.Add(value);
			}
		}

        protected ChannelSource(Uri uri, ChannelSourceCreator creator, ParameterList parameters)
            : base(uri, parameters)
        {
            SetParameterValue(ChannelSourceCreator.CreatorParameterName, creator);

            DownloadSources = new ObservableDownloadSourceCollection();
        }

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            SitemapScope SitemapScope;
            if (parameters.TryGetParameter<SitemapScope>("SitemapScope", out SitemapScope) == false)
            {
                SitemapScope = SitemapScope.Current;
            }

            Guid pageId = Guid.Empty;

            switch (SitemapScope)
            {
                case SitemapScope.Current:
                    pageId = PageRenderer.CurrentPageId;
                    break;
                case SitemapScope.Parent:
                case SitemapScope.Level1:
                case SitemapScope.Level2:
                case SitemapScope.Level3:
                case SitemapScope.Level4:
                    IEnumerable<Guid> pageIds = PageStructureInfo.GetAssociatedPageIds(PageRenderer.CurrentPageId, SitemapScope);
                    pageId = pageIds.FirstOrDefault();
                    break;
                default:
                    throw new NotImplementedException("Unhandled SitemapScope type: " + SitemapScope.ToString());
            }

            return pageId;
        }

 internal Statement(IHost host)
     : base(host)
 {
     Attributes = new AttributeList(host);
     Children = new StatementList(host);
     Parameters = new ParameterList(host);
 }

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            string commaSeparatedSearchTerms = parameters.GetParameter<string>("CommaSeparatedGuids");

            if (!commaSeparatedSearchTerms.IsNullOrEmpty())
            {
                ParameterExpression parameter = Expression.Parameter(typeof(Guid), "g");

                IEnumerable<string> guidStrings = commaSeparatedSearchTerms.Split(',');

                Expression body = null;

                foreach (string guidString in guidStrings)
                {
                    Guid temp = new Guid(guidString.Trim());

                    Expression part = Expression.Equal(parameter, Expression.Constant(temp));

                    body = body.NestedOr(part);
                }

                if(body != null)
                {
                    return Expression.Lambda<Func<Guid, bool>>(body, parameter);
                }
            }

            return (Expression<Func<Guid, bool>>) (f => false);
        }

        public override XElement GetWidgetMarkup(ParameterList parameters, string label, HelpDefinition help, string bindingSourceName)
        {
            string markup = parameters.GetParameter<string>(MarkupParameterName) ?? "";

            if (string.IsNullOrWhiteSpace(markup))
            {
                return null;
            }

            markup = @"<cms:formdefinition xmlns:cms=""http://www.composite.net/ns/management/bindingforms/1.0"" xmlns=""http://www.composite.net/ns/management/bindingforms/std.ui.controls.lib/1.0"">"
                      + markup
                      + "</cms:formdefinition>";

            XElement xml = XElement.Parse(markup);

            foreach (var attribute in xml.Descendants().SelectMany(node => node.Attributes()))
            {
                attribute.Value = attribute.Value
                                    .Replace("$label",  label)
                                    .Replace("$binding", bindingSourceName)
                                    .Replace("$help", help != null ? help.HelpText : "");
            }

            return xml.Elements().FirstOrDefault();
        }

		public override object Execute(ParameterList parameters, FunctionContextContainer context)
		{
			var result = new XhtmlDocument();
			var functionCall = new XElement(Composite.Core.Xml.Namespaces.Function10 + "function",
				new XAttribute("name", "Composite.Forms.RendererControl"));
			BaseRuntimeTreeNode paramNode = null;

			foreach (var parameterName in parameters.AllParameterNames)
			{
				try
				{

					if (parameters.TryGetParameterRuntimeTreeNode(parameterName, out paramNode))
					{
						functionCall.Add(paramNode.Serialize());
					}
				}
				//Ignore
				catch { }
			}
			result.Body.Add(
				new XElement(Namespaces.AspNetControls + "form",
					functionCall));
			return result;
		}

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            IEnumerable<string> strings = parameters.GetParameter<IEnumerable<string>>("Strings");
            string separator = parameters.GetParameter<string>("Separator");

            return string.Join(separator, strings.ToArray());
        }

        public override object Execute(ParameterList parameters, FunctionContextContainer context)
        {
            IEnumerable elements = parameters.GetParameter<IEnumerable>("Elements");
            string keyPropertyName = parameters.GetParameter<string>("KeyPropertyName");
            string valuePropertyName = parameters.GetParameter<string>("ValuePropertyName");

            Dictionary<string, string> resultDictionary = new Dictionary<string, string>();

            PropertyInfo keyPropertyInfo = null;
            PropertyInfo valuePropertyInfo = null;
            foreach (object element in elements)
            {
                if (keyPropertyInfo == null)
                {
                    keyPropertyInfo = element.GetType().GetProperty(keyPropertyName);
                }

                if (valuePropertyInfo == null)
                {
                    valuePropertyInfo = element.GetType().GetProperty(valuePropertyName);
                }

                string keyValue = keyPropertyInfo.GetValue(element, null).ToString();
                string valueValue = valuePropertyInfo.GetValue(element, null).ToString();

                resultDictionary.Add(keyValue, valueValue);
            }

            return resultDictionary;
        }

 public override object Execute(ParameterList parameters, FunctionContextContainer context)
 {
     return new TitleControl {
         PrefixToRemove = parameters.GetParameter<string>("PrefixToRemove"),
         PostfixToRemove = parameters.GetParameter<string>("PostfixToRemove")
     };
 }

        public override ISource Create(Uri uri, string pageData)
        {
            string userHref = pageData.GetStringBetween("<link rel=\"canonical\"", " href=\"", "\"");
            string username = userHref.GetStringBetween("/user/", null);

            string title = pageData.GetStringBetween("<meta name=\"title\" content=\"", "\"");
            string description = pageData.GetStringBetween("<meta name=\"description\" content=\"", "\"");
            string thumbnail = pageData.GetStringBetween("<meta property=\"og:image\" content=\"", "\"");

            // thumbnail format changed (no http/s)
            // //i1.ytimg.com/i/dbL-i29FDPYok8X8yIynNQ/1.jpg?v=9aee31

            string ajaxSessionInfo = pageData.GetStringBetween("window.ajax_session_info", "'", "'");

            var parameters = new ParameterList();
            parameters.AddValue(UserParameterName, username);
            parameters.AddValue(UserHrefParameterName, userHref);
            parameters.AddValue(TitleParameterName, title);
            parameters.AddValue(DescriptionParameterName, description);
            parameters.AddValue(ThumbnailParameterName, thumbnail);
            parameters.AddValue(AjaxSessionInfoParameterName, ajaxSessionInfo);

            var channelSource = new YoutubeVideoChannelSource(uri, this, parameters);

            var downloadSources = ParseDownloadSources(pageData, channelSource);
            foreach (var downloadSource in downloadSources)
                channelSource.Add(downloadSource);

            return channelSource;
        }

		public PlayLandFromHand(ParameterList<IContext> extraParameters):base(extraParameters) {
			Func<IContext,List<string>> identitySelector = (context) => {
				var card = context as Card;
				return new List<string> () { card.Id }; 
			};
			parameters.Add(new Parameter<IContext>("target",identitySelector));
		}