Click here to Skip to main content
Click here to Skip to main content
Articles » Languages » C# » Samples » Downloads
 
Add your own
alternative version

RSS 2.0 Framework

, 19 Jan 2013
RSS 2.0 framework implements the RSS 2.0 specification in strongly typed classes. The framework enables you to create and consume valid RSS 2.0 feeds in your code in just a few minutes.
rssframework_bin.zip
rssframework_demo.zip
Raccoom.Bin
DockingManagerExtender.dll
MagicLibrary.DLL
nunit.framework.dll
Raccoom.Windows.Forms
Windows
Forms
Design
Raccoom.Xml
Properties
Raccoom.Xml.csproj.user
Xml
atom.xsx
Raccoom.Xml.Editors
ActionList
Actions
Design
App.ico
Raccoom.Xml.Editors.csproj.user
Windows
Forms
Raccoom.Xml.Test
Resources
rsschannel.rss
bin
rssframework_help.zip
rssframework_src.zip
rsschannel.rss
Raccoom.Xml.csproj.user
atom.xsx
setup.zip
// Copyright � 2006 by Christoph Richner. All rights are reserved.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
// website http://www.raccoom.net, email support@raccoom.net, msn chrisdarebell@msn.com

using System;
using System.Diagnostics;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing.Design;
using System.Reflection;

namespace Actions
{
	/// <summary>
	/// A collection that stores Action Actions.
	/// </summary>
	[Editor(typeof(ActionCollectionEditor), typeof(UITypeEditor))]
	public class ActionCollection : CollectionBase 
	{
		private ActionList	_owner;
		private Action		_null = new Action();

		/// <summary>
		///  Initializes a new instance of ActionCollection.
		/// </summary>
		public ActionCollection(ActionList owner) 
		{
			Debug.Assert(owner != null);
			_owner = owner;
			_null._owner = _owner;
		}
		/// <summary>
		/// Initialises a new instance of ActionCollection based on another ActionCollection.
		/// </summary>
		/// <param name='value'>An ActionCollection from which the contents are copied</param>
		public ActionCollection(ActionCollection value) 
		{
			this.AddRange(value);
		}
        
		/// <summary>
		/// Initialises a new instance of ActionCollection containing any array of Actions.
		/// </summary>
		/// <param name='value'>An array of Actions with which to intialize the collection</param>
		public ActionCollection(Action[] value) 
		{
			this.AddRange(value);
		}
        
		/// <summary>
		/// Returns the ActionList which owns this ActionCollection
		/// </summary>
		public ActionList Parent
		{
			get
			{
				return _owner;
			}
		}

		/// <summary>
		/// Returns a reference to the "null" action of this collection (needed in design mode)
		/// </summary>
		internal Action Null
		{
			get
			{
				return _null;
			}
		}

		/// <summary>
		/// Represents the entry at the specified index.
		/// </summary>
		/// <param name='index'>The zero-based index of the entry to locate in the collection.</param>
		/// <returns>The entry at the specified index of the collection.</returns>
		public Action this[int index] 
		{
			get 
			{
				return ((Action)(List[index]));
			}
			set 
			{
				List[index] = value;
			}
		}
        
		/// <summary>
		/// Adds a Action with the specified value to the ActionCollection.
		/// </summary>
		/// <param name='value'>The Action to add.</param>
		/// <returns>The index at which the new element was inserted.</returns>
		public int Add(Action value) 
		{
			return List.Add(value);
		}
        
		/// <summary>
		/// Copies the elements of an array to the end of the ActionCollection.
		/// </summary>
		/// <param name='value'> An array of Actions containing the objects to add to the collection.</param>
		public void AddRange(Action[] value) 
		{
			foreach (Action a in value) 
			{
				this.Add(a);
			}
		}
        
		/// <summary>
		/// Adds the contents of another ActionCollection to the end of the collection.
		/// </summary>
		/// <param name='value'>An ActionCollection containing the objects to add to the collection.</param>
		public void AddRange(ActionCollection value) 
		{
			foreach (Action a in value) 
			{
				this.Add(a);
			}
		}
        
		/// <summary>
		/// Returns true if this ActionCollection contains the specified Action.
		/// </summary>
		/// <param name='value'>The Action to locate.</param>
		public bool Contains(Action value) 
		{
			return List.Contains(value);
		}
        
		/// <summary>
		/// Copies the ActionCollection values to a one-dimensional Array instance at the  specified index.
		/// </summary>
		/// <param name='array'>The one-dimensional Array that is the destination of the values copied from ActionCollection .</param>
		/// <param name='index'>The index in <paramref name='array'/> where copying begins.</param>
		public void CopyTo(Action[] array, int index) 
		{
			List.CopyTo(array, index);
		}
        
		/// <summary>Returns the index of an Action in the ActionCollection.</summary>
		/// <param name='value'>The Action to locate.</param>
		/// <returns>The index of the Action of <paramref name='value'/> in the ActionCollection, if found; otherwise, -1.</returns>
		public int IndexOf(Action value) 
		{
			return List.IndexOf(value);
		}
        
		/// <summary>Inserts a Action into the ActionCollection at the specified index.</summary>
		/// <param name='index'>The zero-based index where <paramref name='value'/> should be inserted.</param>
		/// <param name=' value'>The Action to insert.</param>
		public void Insert(int index, Action value) 
		{
			List.Insert(index, value);
		}
        
		/// <summary>Returns an enumerator that can iterate through  the ActionCollection.</summary>
		public new ActionEnumerator GetEnumerator() 
		{
			return new ActionEnumerator(this);
		}
        
		/// <summary>
		/// Removes a specific Action from the ActionCollection.
		/// </summary>
		/// <param name='value'>The Action to remove from the ActionCollection .</param>
		public void Remove(Action value) 
		{
			List.Remove(value);
		}
        
		protected override void OnSet(int index, object oldValue, object newValue) 
		{
			if (oldValue != null) ((Action)oldValue)._owner = null;
			if (newValue != null) ((Action)newValue)._owner = _owner;
		}
        
		protected override void OnInsert(int index, object value) 
		{
			if (value != null) ((Action)value)._owner = _owner;
		}
        
		protected override void OnClear() 
		{
		}
        
		protected override void OnRemove(int index, object value) 
		{
		}
        
		protected override void OnValidate(object value) 
		{
		}
     
		/// <summary>
		/// An enumerator for an ActionCollection
		/// </summary>
		public class ActionEnumerator : object, IEnumerator 
		{
            
			private IEnumerator _baseEnumerator;
			private IEnumerable _temp;
            
			public ActionEnumerator(ActionCollection mappings) 
			{
				this._temp = ((IEnumerable)(mappings));
				this._baseEnumerator = _temp.GetEnumerator();
			}
            
			public Action Current 
			{
				get 
				{
					return ((Action)(_baseEnumerator.Current));
				}
			}
            
			object IEnumerator.Current 
			{
				get 
				{
					return _baseEnumerator.Current;
				}
			}
            
			public bool MoveNext() 
			{
				return _baseEnumerator.MoveNext();
			}
            
			bool IEnumerator.MoveNext() 
			{
				return _baseEnumerator.MoveNext();
			}
            
			public void Reset() 
			{
				_baseEnumerator.Reset();
			}
            
			void IEnumerator.Reset() 
			{
				_baseEnumerator.Reset();
			}
		}
	}
}

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The GNU Lesser General Public License (LGPLv3)

Share

About the Author

Chris Richner
Software Developer (Senior) Zeit AG
Switzerland Switzerland
Biography
  • 1996 - 1998 PC Board PPL, HTML, DHTML, Javascript and ASP
  • 1999 - 2001 coding Centura against Sql Database (SqlBase,MSSQL,Oracle)
  • 2002 - 2004 C# Windows Forms
  • 2005 - 2006 C# ASP.NET, Windows Forms
  • 2006 - 2009 C#, WCF, WF, WPF
  • 2010 - 2012 C#, Dynamics CRM, Sharepoint, Silverlight
  • 2013 - now C#, WCF DS (OData), WF, WPF
Interests
  • family & friends
  • chilaxing ,)
  • coding
Follow on   Twitter   Google+   LinkedIn

| Advertise | Privacy | Mobile
Web03 | 2.8.140821.2 | Last Updated 20 Jan 2013
Article Copyright 2003 by Chris Richner
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid