void Users_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<Collections.IndexedItem<User>> e) {
   foreach (var u in e.Items) {
     if (u.Value.Id != Guid.Empty) {
       Content.DeleteUserAsync(u.Value, PluginInfrastructure.ErrorHandling.ShowErrorDialog);
     }
   }
 }

 /// <summary>
 /// Loads the object definitions.
 /// </summary>
 /// <param name="configurationModel">The configuration model.</param>
 public void LoadObjectDefinitions(Collections.Generic.ISet<ConfigurationClass> configurationModel)
 {
     foreach (ConfigurationClass configClass in configurationModel)
     {
         LoadObjectDefinitionsForConfigurationClass(configClass);
     }
 }

 private RandomGenR()
 {
     this.dateModule = new Dates();
     this.numberModule = new Numbers();
     this.collectionsModule = new Collections();
     this.stringsModule = new Strings();
 }

        public SocketToken(int id,
            Sinan.Collections.BytesSegment receiveBuffer,
            Sinan.Collections.BytesSegment sendBuffer,
            IBufferProcessor processor,
            Collections.CircularQueue<Collections.BytesSegment> sendPool = null)
        {
            m_connectID = id;
            m_sendPool = sendPool ?? new Collections.CircularQueue<Collections.BytesSegment>(64);
            m_processor = processor;
            SocketAsyncEventArgs receiver = new SocketAsyncEventArgs();
            receiver.Completed += new EventHandler<SocketAsyncEventArgs>(ReceiveCompleted);
            receiver.SetBuffer(receiveBuffer.Array, receiveBuffer.Offset, receiveBuffer.Count);

            SocketAsyncEventArgs sender = new SocketAsyncEventArgs();
            sender.Completed += new EventHandler<SocketAsyncEventArgs>(SendCompleted);
            sender.SetBuffer(sendBuffer.Array, sendBuffer.Offset, sendBuffer.Count);

            m_receiver = receiver;
            m_receiveOffset = receiver.Offset;
            m_receiveMax = receiver.Count;

            m_sender = sender;
            m_sendOffset = sender.Offset;
            m_sendMax = sender.Count;
        }

	    /// <summary>
	    /// Create a new QualifierAnnotationAutowireCandidateResolver
	    /// for the given qualifier attribute types.
	    /// </summary>
	    /// <param name="qualifierTypes">the qualifier annotations to look for</param>
	    public QualifierAnnotationAutowireCandidateResolver(Collections.Generic.ISet<Type> qualifierTypes) {
            AssertUtils.ArgumentNotNull(qualifierTypes, "'qualifierTypes' must not be null");
            foreach(var type in qualifierTypes)
            {
                if (!_qualifierTypes.Contains(type))
                    _qualifierTypes.Add(type);
            }
	    }

        public override void Initialise(Collections.INamedDataProvider initialisationData)
        {
            base.Initialise(initialisationData);

            initialisationData.TryCopyValue(this, TextureName, _texture);
            initialisationData.TryCopyValue(this, BrightnessName, _brightness);
            initialisationData.TryCopyValue(this, GammaCorrectName, _gammaCorrect);
        }

        public override void Initialise(Collections.INamedDataProvider initialisationData)
        {
            base.Initialise(initialisationData);

            initialisationData.TryCopyValue(this, SkyColourName, _skyColour);
            initialisationData.TryCopyValue(this, GroundColourName, _groundColour);
            initialisationData.TryCopyValue(this, UpName, _up);
        }

 private void Content_CheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IFilter> e) {
   if (Content != null) {
     foreach (IFilter filter in e.Items) {
       filter.Active = checkedFilterView.Content.ItemChecked(filter);
     }
     UpdateFilterInfo();
   }
 }

    public Parser(Collections.IList<object> tokens)
    {
        this.tokens = tokens;
        this.index = 0;
        this.result = this.ParseStmt();

        if (this.index != this.tokens.Count)
            throw new System.Exception("expected EOF");
    }

        public override void Initialise(Collections.INamedDataProvider initialisationData)
        {
            base.Initialise(initialisationData);

            initialisationData.TryCopyValue(this, ColourName, _colour);
            initialisationData.TryCopyValue(this, DirectionName, _direction);
            initialisationData.TryCopyValue(this, ShadowResolutionName, _shadowResolution);
            initialisationData.TryCopyValue(this, ActiveName, _active);
        }

    public Parser(Collections.IList<object> tokens)
    {
        this.tokens = tokens;
        this.indice = 0;
        this.resultado = this.ParseStmt();

        if (this.indice != this.tokens.Count)
            throw new System.Exception("se esperaba el final del archivo");
    }

        public override void Initialise(Collections.INamedDataProvider initialisationData)
        {
            base.Initialise(initialisationData);

            initialisationData.TryCopyValue(this, ColourName, _colour);
            initialisationData.TryCopyValue(this, PositionName, _position);
            initialisationData.TryCopyValue(this, RangeName, _range);
            initialisationData.TryCopyValue(this, ActiveName, _active);
        }

     public MethodParamPair(
 MethodParamResult method,
 Interfaces.IEventInput input,
         Collections.ExitPathGroup _paths)
     {
         _result = MethodResult.None;
         _method = method;
         _params = input;
         _exitPaths = _paths;
     }

        protected override void OnItemsChanged(Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            if (e.Action == Collections.Specialized.NotifyCollectionChangedAction.Remove)
            {
                // Don't select itself when its child items got removed. (Default action of base.OnItemsChanged)
                // The selection should be managed by designer surface.
                return;
            }

            base.OnItemsChanged(e);
        }

        internal static Node<TreeNode> CreateNode(this HierarchyNode<ContentItem> structure, IContentAdapterProvider adapters, Collections.ItemFilter filter)
        {
            var adapter = adapters.ResolveAdapter<NodeAdapter>(structure.Current);

            var children = structure.Children.Select(c => CreateNode(c, adapters, filter)).ToList();
            return new Node<TreeNode>
            {
                Current = adapter.GetTreeNode(structure.Current),
                HasChildren = adapter.HasChildren(structure.Current, filter),
                Expanded = children.Any(),
                Children = children
            };
        }

        /// <summary>
        /// Checks for emty runner instances.
        /// </summary>
        /// <param name="runners">The runners.</param>
        /// <returns></returns>
        public static Collections.SelectionList CheckForEmtyRunnerInstances(Collections.SelectionList runners)
        {
            if (runners == null) return runners;

            int removeAt = -1;

            for (int x = 0; x < runners.Count; x++)
            {
                if (runners[x].selectionId <= 0) removeAt = x;
            }

            if (removeAt > -1) runners.RemoveAt(removeAt);

            return runners;
        }

        static void Main(string[] args)
        {
            IEnumerable<int> list = new List<int>() { 1, 2, 3, 5 };

            foreach (int number in list)
            {
                Console.WriteLine(number);
            }

            // ... e echivalent cu:
            using (var enumerator = list.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    int number = enumerator.Current;
                    Console.WriteLine(number);
                }
            }

            var collections = new Collections();
            foreach (var dwarf in collections.TheSevenDwarves())
            {
                Console.WriteLine("Here comes {0}", dwarf);
            }

            var fibonacci = collections.Fibonacci();
            var firstFibonacci = collections.FirstTwelve(fibonacci);
            foreach (var n in firstFibonacci)
            {
                Console.WriteLine(n);
            }

            Console.WriteLine("------------------------------------------");

            var newFibonacci = collections.Fibonacci();
            var evenFibonacci = collections.OnlyEven(newFibonacci);
            var firstEvenFibonacci = collections.FirstTwelve(evenFibonacci);
            foreach (var n in firstEvenFibonacci)
            {
                Console.WriteLine(n);
            }
        }

		protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, Collections.NameValuePairList createParams )
		{
			string paramSyntax = string.Empty;
			string paramType = string.Empty;

			if ( createParams == null || createParams.ContainsKey( "syntax" ) == false || createParams.ContainsKey( "type" ) == false )
			{
				throw new AxiomException( "You must supply 'syntax' and 'type' parameters" );
			}
			else
			{
				paramSyntax = createParams[ "syntax" ];
				paramType = createParams[ "type" ];
			}
			CreateGpuProgramDelegate iter = null;
			if ( this._programMap.ContainsKey( paramSyntax ) )
			{
				iter = this._programMap[ paramSyntax ];
			}
			else
			{
				// No factory, this is an unsupported syntax code, probably for another rendersystem
				// Create a basic one, it doesn't matter what it is since it won't be used
				return new GLES2GpuProgram( this, name, handle, group, isManual, loader );
			}
			GpuProgramType gpt;
			if ( paramType == "vertex_program" )
			{
				gpt = GpuProgramType.Vertex;
			}
			else
			{
				gpt = GpuProgramType.Fragment;
			}

			return iter( this, name, handle, group, isManual, loader, gpt, paramSyntax );
		}

		public void ComboBox_Initialize(Collections.SelectableListNodeList items, Collections.SelectableListNode defaultItem)
		{
			_cbComboBox.ItemsSource = null;
			_cbComboBox.ItemsSource = items;
			_cbComboBox.SelectedItem = defaultItem;
		}

 private void effectPool_EffectRemoved(object sender, Collections.ObservableCollectionEventArgs<Effect> e)
 {
     RemoveEffect(e.Item);
 }