C# IDataContainer类代码示例

        public override IDataContainer PreProcess(IDataContainer dataContainer)
        {
            if (dataContainer.OfType<BlobData>().Any())
            {
                if (StagedData.OfType<BlobData>().Any())
                    Push();

                foreach (var data in dataContainer)
                    Stage(data);
            }
            else if (dataContainer.OfType<Marker>().Any())
            {
                if (StagedData.OfType<Marker>().Any())
                    Push();

                foreach (var data in dataContainer)
                    Stage(data);
            }
            else if (dataContainer.OfType<Hand>().Any())
            {
                if (StagedData.OfType<Hand>().Any())
                    Push();

                foreach (var data in dataContainer)
                    Stage(data);
            }

            return null;
        }

 /// <summary>
 /// Creates a new instance of a TemplateData object that will be used to generate code from a template
 /// </summary>
 /// <param name="DataContainer">A table or view</param>
 /// <param name="UserName">The user who will be named as the author in the genrated code files</param>
 /// <param name="RootNamespace">The root namespace to apply to the generated classes</param>
 /// <param name="DatabaseName">The name of the database</param>
 public TemplateData(IDataContainer DataContainer, string UserName, string RootNamespace, string DatabaseName)
 {
     _databaseName = DatabaseName;
     _dataContainer = DataContainer;
     _userName = UserName;
     _rootNamespace = RootNamespace;
 }

 internal static TypeMatcherProperyReader GetTypeMatcherProperyReader(object obj, string objParam, string component, string param, IDataContainer owner)
 {
     TypeMatcherWatcher watcher = TypeMatcherWatcher.GetTypeMatcherWatcher(obj, objParam, owner);
     Func<TypeMatcherProperyReader> create =
         new Func<TypeMatcherProperyReader>(() => new TypeMatcherProperyReader(watcher, component, param));
     string fullParam = component + "." + param;
     return DoubleDictionary<TypeMatcherWatcher, string, TypeMatcherProperyReader>.GetItem(watcher, fullParam, create);
 }

 public override IDataContainer PreProcess(IDataContainer dataContainer)
 {
     if (dataContainer.FrameId % 10 == 0)
     {
         return dataContainer;
     }
     return null;
 }

        public SeasonsList( IViewModelContainer viewModelContainer, IDataContainer dataContainer, ISeriesList seriesList )
            : base(viewModelContainer, dataContainer)
        {
            MessengerInstance.Register<SelectedSeriesChanged>( this, OnSelectedSeriesChanged );
            Seasons = new ObservableCollection<SeasonEntry>();

            OnSelectedSeriesChanged( new SelectedSeriesChanged( seriesList.SelectedSeries ) );
        }

 private TypeMatcherWatcher(object obj, string param, IDataContainer owner)
 {
     Obj = obj;
     Param = param;
     Type objType = obj.GetType();
     Owner = owner;
     if(typeof(IChangeable).IsAssignableFrom(obj.GetType()))
         Owner.NotifyOfComponentChange(new Tuple<IChangeable,string>((IChangeable)obj, param), this);
 }

		public SettingsDialogViewModel( IViewModelContainer viewModelContainer, IDataContainer dataContainer, IAppThemes themes ) : base( viewModelContainer, dataContainer )
		{
			Themes = themes ?? new AppThemes();
			AvailableAccents = Themes.Accents.ToList();
			AvailableThemes = Themes.Themes.ToList();

			AvailableLanguages = new List<CultureInfo>( ViewModelContainer.LanguageProvider.AvailableLanguages.OrderBy( l => l.NativeName ) );
			AvailableContentLanguages = Repositories.Languages.GetAll().Select( l => l.Culture ).OrderBy( l => l.NativeName ).ToList();
		}

        public EpisodesList( IViewModelContainer container, IDataContainer dataContainer, ISeriesList seriesList, ISeasonsList seasonsList )
            : base(container, dataContainer)
        {
            SeriesList = seriesList;

            Episodes = new ObservableCollection<EpisodeEntry>();
            MessengerInstance.Register<SelectedSeasonChanged>( this, OnSelectedSeasonChanged );

            OnSelectedSeasonChanged( new SelectedSeasonChanged( seasonsList?.SelectedSeason?.SeasonNumber ) );
        }

        public EpisodeDetails( IViewModelContainer viewModelContainer, IDataContainer dataContainer, IEpisodesList episodesList )
            : base(viewModelContainer, dataContainer)
        {
            MessengerInstance.Register<SelectedEpisodeChanged>( this, OnSelectedEpisodeChanged );

            Writers = new ObservableCollection<PersonEntry>();
            Directors = new ObservableCollection<PersonEntry>();
            GuestStars = new ObservableCollection<PersonEntry>();

            OnSelectedEpisodeChanged( new SelectedEpisodeChanged( episodesList.SelectedEpisode ) );
        }

		public EpisodeEntry( IViewModelContainer viewModelContainer, IDataContainer dataContainer, Episode model, SeriesEntry series )
			: base( viewModelContainer, dataContainer )
		{
			Series = series;
			Model = model;

			if( model.BannerLocation != null )
			{
				BannerUrl = model.BannerLocation;
			}
		}

        public ValueReader CreateValueReader(string value, IScene scene, IDataContainer entity, Event evt = null)
        {
            ParseTree tree = parser.Parse(value);   // Should always be valid since UI calls HasErrors first
            var assignable = MakeAssignable(tree.Root, scene, entity, evt);

            var reader = assignable as ValueReader;
            if (null == reader)
            {
                var typeMatcher = assignable as TypeMatcher;
                if (null != typeMatcher)
                {
                    reader = ConstantReader.NullValue;
                }
            }

            return reader;
        }

        public override IDataContainer PreProcess(IDataContainer dataContainer)
        {
            var push = false;
            Parallel.ForEach(StagedData, staged =>
            {
                if (dataContainer.Any(d => d.Source.Equals(staged.Source)))
                push = true;
            });

            if (push)
                Push();

            //foreach (var data in dataContainer.OfType<BlobData>())
            //    Stage(data);

            Stage(dataContainer.ToArray());

            return null;
        }

		public SeriesEntry( IViewModelContainer viewModelContainer, IDataContainer dataContainer, Series model )
			: base( viewModelContainer, dataContainer )
		{
			Model = model;

			var allEpisodes = Model.Episodes.Where( e => e.SeasonNumber != 0 ).ToArray();

			Episodes = new ObservableCollection<EpisodeEntry>( allEpisodes.Select( e => new EpisodeEntry( viewModelContainer, dataContainer, e, this ) ) );
			Seasons =
				new ObservableCollection<SeasonEntry>( allEpisodes.Select( e => e.SeasonNumber ).Distinct().Select( n => new SeasonEntry( viewModelContainer, dataContainer, n, this ) ) );

			Name = model.Name;
			Rating = model.Rating;
			RatingsCount = model.Ratings;

			if( model.BannerLocation != null )
			{
				BannerUrl = model.BannerLocation;
			}
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dataContainer"></param>
        /// <returns></returns>
        public override IDataContainer PreProcess(IDataContainer dataContainer)
        {
            var rgbImages = dataContainer.OfType<RgbImageData>().ToArray();
            if (rgbImages.Any())
            {
                if (_rgbImageData != null)
                    _rgbImageData.Dispose();

                _rgbImageData = rgbImages.First().Copy() as RgbImageData;
                return null;
            }

            if (_rgbImageData != null)
            {
                dataContainer.Add(_rgbImageData.Copy());
                _rgbImageData.Dispose();
                _rgbImageData = null;
            }

            return dataContainer;
        }

        public override IDataContainer PreProcess(IDataContainer dataContainer)
        {
            const int width = 1280;
            const int height = 720;
            var image = new Image<Rgb, byte>(width, height);

            foreach (var blob in dataContainer.OfType<BlobData>())
            {
                var polyline = new List<Point>();
                foreach (var point in blob.Polygon.Points)
                {
                    var x = point.X * width;
                    var y = point.Y * height;

                    polyline.Add(new Point((int)x, (int)y));
                }

                var color = Rgbs.White;
                if (typeof(RectangleTracker) == blob.Source.GetType())
                    color = Rgbs.Red;
                else if (typeof(RectangleTrackerColor) == blob.Source.GetType())
                    color = Rgbs.Yellow;

                var centerX = (int)(blob.Center.X * width);
                var centerY = (int)(blob.Center.Y * height);

                image.DrawPolyline(polyline.ToArray(), true, color, 5);
                image.Draw(string.Format("Id {0}", blob.Id), ref EmguFontBig, new Point(centerX, centerY), Rgbs.White);
            }

            Stage(new RgbImageData(this, "BlobRenderer", image.Copy()));
            Push();

            image.Dispose();

            return null;
        }