NativeActivityMetadata.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / NetFx40 / System.Activities / System / Activities / NativeActivityMetadata.cs / 1305376 / NativeActivityMetadata.cs

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.Activities 
{
    using System; 
    using System.Activities.Validation; 
    using System.Collections.ObjectModel;
 
    public struct NativeActivityMetadata
    {
        Activity activity;
        LocationReferenceEnvironment environment; 
        bool createEmptyBindings;
 
        internal NativeActivityMetadata(Activity activity, LocationReferenceEnvironment environment, bool createEmptyBindings) 
        {
            this.activity = activity; 
            this.environment = environment;
            this.createEmptyBindings = createEmptyBindings;
        }
 
        internal bool CreateEmptyBindings
        { 
            get 
            {
                return this.createEmptyBindings; 
            }
        }

        public LocationReferenceEnvironment Environment 
        {
            get 
            { 
                return this.environment;
            } 
        }

        public bool HasViolations
        { 
            get
            { 
                if (this.activity == null) 
                {
                    return false; 
                }
                else
                {
                    return this.activity.HasTempViolations; 
                }
            } 
        } 

        public static bool operator ==(NativeActivityMetadata left, NativeActivityMetadata right) 
        {
            return left.Equals(right);
        }
 
        public static bool operator !=(NativeActivityMetadata left, NativeActivityMetadata right)
        { 
            return !left.Equals(right); 
        }
 
        public override bool Equals(object obj)
        {
            if (!(obj is NativeActivityMetadata))
            { 
                return false;
            } 
 
            NativeActivityMetadata other = (NativeActivityMetadata)obj;
            return other.activity == this.activity && other.Environment == this.Environment 
                && other.CreateEmptyBindings == this.CreateEmptyBindings;
        }

        public override int GetHashCode() 
        {
            if (this.activity == null) 
            { 
                return 0;
            } 
            else
            {
                return this.activity.GetHashCode();
            } 
        }
 
        public void Bind(Argument binding, RuntimeArgument argument) 
        {
            ThrowIfDisposed(); 

            Argument.TryBind(binding, argument, this.activity);
        }
 
        public void SetValidationErrorsCollection(Collection validationErrors)
        { 
            ThrowIfDisposed(); 

            ActivityUtilities.RemoveNulls(validationErrors); 

            this.activity.SetTempValidationErrorCollection(validationErrors);
        }
 
        public void AddValidationError(string validationErrorMessage)
        { 
            AddValidationError(new ValidationError(validationErrorMessage)); 
        }
 
        public void AddValidationError(ValidationError validationError)
        {
            ThrowIfDisposed();
 
            if (validationError != null)
            { 
                this.activity.AddTempValidationError(validationError); 
            }
        } 

        public void SetArgumentsCollection(Collection arguments)
        {
            ThrowIfDisposed(); 

            ActivityUtilities.RemoveNulls(arguments); 
 
            this.activity.SetArgumentsCollection(arguments, this.createEmptyBindings);
        } 

        public void AddArgument(RuntimeArgument argument)
        {
            ThrowIfDisposed(); 

            if (argument != null) 
            { 
                this.activity.AddArgument(argument, this.createEmptyBindings);
            } 
        }

        public void SetChildrenCollection(Collection children)
        { 
            ThrowIfDisposed();
 
            ActivityUtilities.RemoveNulls(children); 

            this.activity.SetChildrenCollection(children); 
        }

        public void AddChild(Activity child)
        { 
            ThrowIfDisposed();
 
            if (child != null) 
            {
                this.activity.AddChild(child); 
            }
        }

        public void SetImplementationChildrenCollection(Collection implementationChildren) 
        {
            ThrowIfDisposed(); 
 
            ActivityUtilities.RemoveNulls(implementationChildren);
 
            this.activity.SetImplementationChildrenCollection(implementationChildren);
        }

        public void AddImplementationChild(Activity implementationChild) 
        {
            ThrowIfDisposed(); 
 
            if (implementationChild != null)
            { 
                this.activity.AddImplementationChild(implementationChild);
            }
        }
 
        public void SetImportedChildrenCollection(Collection importedChildren)
        { 
            ThrowIfDisposed(); 

            ActivityUtilities.RemoveNulls(importedChildren); 

            this.activity.SetImportedChildrenCollection(importedChildren);
        }
 
        public void AddImportedChild(Activity importedChild)
        { 
            ThrowIfDisposed(); 

            if (importedChild != null) 
            {
                this.activity.AddImportedChild(importedChild);
            }
        } 

        public void SetDelegatesCollection(Collection delegates) 
        { 
            ThrowIfDisposed();
 
            ActivityUtilities.RemoveNulls(delegates);

            this.activity.SetDelegatesCollection(delegates);
        } 

        public void AddDelegate(ActivityDelegate activityDelegate) 
        { 
            ThrowIfDisposed();
 
            if (activityDelegate != null)
            {
                this.activity.AddDelegate(activityDelegate);
            } 
        }
 
        public void SetImplementationDelegatesCollection(Collection implementationDelegates) 
        {
            ThrowIfDisposed(); 

            ActivityUtilities.RemoveNulls(implementationDelegates);

            this.activity.SetImplementationDelegatesCollection(implementationDelegates); 
        }
 
        public void AddImplementationDelegate(ActivityDelegate implementationDelegate) 
        {
            ThrowIfDisposed(); 

            if (implementationDelegate != null)
            {
                this.activity.AddImplementationDelegate(implementationDelegate); 
            }
        } 
 
        public void SetImportedDelegatesCollection(Collection importedDelegates)
        { 
            ThrowIfDisposed();

            ActivityUtilities.RemoveNulls(importedDelegates);
 
            this.activity.SetImportedDelegatesCollection(importedDelegates);
        } 
 
        public void AddImportedDelegate(ActivityDelegate importedDelegate)
        { 
            ThrowIfDisposed();

            if (importedDelegate != null)
            { 
                this.activity.AddImportedDelegate(importedDelegate);
            } 
        } 

        public void SetVariablesCollection(Collection variables) 
        {
            ThrowIfDisposed();

            ActivityUtilities.RemoveNulls(variables); 

            this.activity.SetVariablesCollection(variables); 
        } 

        public void AddVariable(Variable variable) 
        {
            ThrowIfDisposed();

            if (variable != null) 
            {
                this.activity.AddVariable(variable); 
            } 
        }
 
        public void SetImplementationVariablesCollection(Collection implementationVariables)
        {
            ThrowIfDisposed();
 
            ActivityUtilities.RemoveNulls(implementationVariables);
 
            this.activity.SetImplementationVariablesCollection(implementationVariables); 
        }
 
        public void AddImplementationVariable(Variable implementationVariable)
        {
            ThrowIfDisposed();
 
            if (implementationVariable != null)
            { 
                this.activity.AddImplementationVariable(implementationVariable); 
            }
        } 

        public Collection GetArgumentsWithReflection()
        {
            return Activity.ReflectedInformation.GetArguments(this.activity); 
        }
 
        public Collection GetChildrenWithReflection() 
        {
            return Activity.ReflectedInformation.GetChildren(this.activity); 
        }

        public Collection GetVariablesWithReflection()
        { 
            return Activity.ReflectedInformation.GetVariables(this.activity);
        } 
 
        public Collection GetDelegatesWithReflection()
        { 
            return Activity.ReflectedInformation.GetDelegates(this.activity);
        }

        public void AddDefaultExtensionProvider(Func extensionProvider) 
            where T : class
        { 
            if (extensionProvider == null) 
            {
                throw FxTrace.Exception.ArgumentNull("extensionProvider"); 
            }
            this.activity.AddDefaultExtensionProvider(extensionProvider);
        }
 
        public void RequireExtension()
            where T : class 
        { 
            this.activity.RequireExtension(typeof(T));
        } 

        public void RequireExtension(Type extensionType)
        {
            if (extensionType == null) 
            {
                throw FxTrace.Exception.ArgumentNull("extensionType"); 
            } 
            if (extensionType.IsValueType)
            { 
                throw FxTrace.Exception.Argument("extensionType", SR.RequireExtensionOnlyAcceptsReferenceTypes(extensionType.FullName));
            }
            this.activity.RequireExtension(extensionType);
        } 

        internal void Dispose() 
        { 
            this.activity = null;
        } 

        void ThrowIfDisposed()
        {
            if (this.activity == null) 
            {
                throw FxTrace.Exception.AsError(new ObjectDisposedException(ToString())); 
            } 
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK