/// <inheritdoc />
        public IMetadataObject TryGetFromGitPath(string path)
        {
            if (path == null)
            {
                throw new ArgumentNullException(nameof(path));
            }

            var chunks = path.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);

            IMetadataObject result = this;

            for (int i = 0; i < chunks.Length - 1 && result != null; i++)
            {
                var propertyInfo = result.DataAccessor.ChildProperties.FirstOrDefault(
                    p => p.FolderName.Equals(chunks[i], StringComparison.OrdinalIgnoreCase));
                if (propertyInfo == null)
                {
                    return(null);
                }

                i++;
                if (i >= chunks.Length)
                {
                    return(null);
                }

                var children = propertyInfo.Accessor(result);
                var guid     = Guid.Parse(chunks[i]);
                result = children.FirstOrDefault(c => c.Id == guid);
            }
            return(result);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Gets the folder path containing the data file for a node.
        /// </summary>
        /// <param name="source">The node.</param>
        /// <returns>A <see cref="string"/> value containing the path to the folder.</returns>
        internal static string GetFolderPath(this IMetadataObject source)
        {
            var result = new StringBuilder();

            GetFolderPath(source, result);
            return(result.ToString());
        }
Exemplo n.º 3
0
		/// <summary>
		///     Initializes a new instance.
		/// </summary>
		/// <param name="obj">The S# object the method belongs to.</param>
		/// <param name="method">The CLR method the metadata should be provided for.</param>
		/// <param name="name">The name of the method; if <c>null</c>, the method's CLR name is used.</param>
		/// <param name="baseMethod">The overridden base method, if any.</param>
		internal MethodMetadata(IMetadataObject obj, MethodInfo method, string name = null, MethodMetadata baseMethod = null)
		{
			Requires.NotNull(obj, () => obj);
			Requires.NotNull(method, () => method);
			Requires.That(name == null || !String.IsNullOrWhiteSpace(name), () => name, "The name must be null or non-whitespace only.");
			Requires.That(baseMethod == null || method != baseMethod.MethodInfo, "A method cannot override itself.");
			Requires.That(baseMethod == null || obj == baseMethod._object, "The base method must belong to the same object.");
			Requires.That(baseMethod == null || baseMethod.OverridingMethod == null, "The base method has already been overridden.");

			_object = obj;

			Name = EscapeName(name ?? method.Name);
			MethodInfo = method;
			BaseMethod = baseMethod;

			if (baseMethod != null)
				baseMethod.OverridingMethod = this;

			var backingFieldAttribute = MethodInfo.GetCustomAttribute<BackingFieldAttribute>();
			if (backingFieldAttribute != null)
				BackingField = backingFieldAttribute.GetFieldInfo(MethodInfo.DeclaringType);

			var behaviorAttribute = MethodInfo.GetCustomAttribute<IntendedBehaviorAttribute>();
			if (behaviorAttribute != null)
				IntendedBehavior = behaviorAttribute.GetMethodInfo(MethodInfo.DeclaringType);

			if (backingFieldAttribute == null && behaviorAttribute == null)
				IntendedBehavior = MethodInfo;

			Behaviors = new MethodBehaviorCollection(obj, this);
			ImplementedMethods = DetermineImplementedInterfaceMethods().ToArray();

			_methodBody = new Lazy<MethodBodyMetadata>(InitializeMethodBody);
		}
Exemplo n.º 4
0
        IMetadataObject DeepClone(IMetadataObject node, ProcessArgument processArgument, ChildChangesGetter childChangesGetter, Func <IMetadataObject, bool> mustForceVisit)
        {
            if (node == null)
            {
                throw new ArgumentNullException(nameof(node));
            }
            if (processArgument == null)
            {
                throw new ArgumentNullException(nameof(processArgument));
            }
            if (childChangesGetter == null)
            {
                throw new ArgumentNullException(nameof(childChangesGetter));
            }
            if (mustForceVisit == null)
            {
                throw new ArgumentNullException(nameof(mustForceVisit));
            }

            ILazyChildren ProcessChildren(ChildPropertyInfo childProperty, ILazyChildren children, IMetadataObject @new, IModelDataAccessor childDataAccessor)
            {
                var childChanges = childChangesGetter.Invoke(node, childProperty);

                return(children.Clone(
                           forceVisit: mustForceVisit(children.Parent),
                           update: n => DeepClone(n, processArgument, childChangesGetter, mustForceVisit),
                           added: childChanges.Additions,
                           deleted: childChanges.Deletions));
            }

            return(node.DataAccessor.ConstructorParameterBinding.Cloner(node, processArgument, ProcessChildren));
        }
Exemplo n.º 5
0
        static Regex GetChildPathRegex(IMetadataObject node, ChildPropertyInfo childProperty)
        {
            var path = node.GetFolderPath();

            return(string.IsNullOrEmpty(path) ?
                   new Regex($@"{childProperty.FolderName}/[\w-]+/{FileSystemStorage.DataFile}", RegexOptions.IgnoreCase) :
                   new Regex($@"{path}/{childProperty.FolderName}/[\w-]+/{FileSystemStorage.DataFile}", RegexOptions.IgnoreCase));
        }
Exemplo n.º 6
0
 /// <summary>
 /// Serializes the node into the <paramref name="stringBuilder"/>.
 /// </summary>
 /// <param name="source">The source.</param>
 /// <param name="stringBuilder">The string builder.</param>
 internal static void ToJson(this IMetadataObject source, StringBuilder stringBuilder)
 {
     stringBuilder.Clear();
     using (var writer = new StringWriter(stringBuilder))
     {
         _jsonSerializer.Serialize(writer, source);
     }
 }
Exemplo n.º 7
0
 static void UpdateNodeIfNeeded(IMetadataObject original, IMetadataObject @new, Stack<string> stack, IModelDataAccessor accessor, IList<MetadataTreeEntryChanges> changes)
 {
     if (accessor.ModifiableProperties.Any(p => !p.AreSame(original, @new)))
     {
         var path = stack.ToDataPath();
         changes.Add(new MetadataTreeEntryChanges(path, ChangeKind.Modified, original, @new));
     }
 }
Exemplo n.º 8
0
		/// <summary>
		///     Initializes a new instance.
		/// </summary>
		/// <param name="obj">The S# object the method belongs to.</param>
		/// <param name="method">The metadata of the method the behavior belongs to.</param>
		internal FaultInjection(IMetadataObject obj, MethodMetadata method)
		{
			Requires.NotNull(obj, () => obj);
			Requires.NotNull(method, () => method);

			_object = obj;
			Method = method;
		}
Exemplo n.º 9
0
 TLink GetValueFromFactory(IMetadataObject parent)
 {
     if (_factory == null)
     {
         throw new NotSupportedException("Factory cannot be null.");
     }
     return(_factory(parent) ?? throw new NotSupportedException(_nullReturnedValueExceptionMessage));
 }
Exemplo n.º 10
0
        /// <summary>
        /// Gets an <see cref="IEnumerable{IMetadataObject}"/> containing all parents of this node.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <returns>All parent nodes from nearest to farest.</returns>
        public static IEnumerable <IMetadataObject> Parents(this IMetadataObject source)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }

            return(ParentsIterator(source));
        }
Exemplo n.º 11
0
        public void LazyChildrenThrowsErrorIfLambdaReturnsNull(IMetadataObject parent)
        {
            // Act
            var sut = new LazyChildren <IMetadataObject>(_ => null);

            sut.AttachToParent(parent);

            // Assert
            Assert.Throws <NotSupportedException>(() => sut.GetEnumerator());
        }
Exemplo n.º 12
0
        static IEnumerable <IMetadataObject> ParentsIterator(IMetadataObject source)
        {
            var node = source;

            while (node != null)
            {
                yield return(node);

                node = node.Parent;
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Возвращает интерфейс объекта метаданных.
        /// </summary>
        /// <param name="metadataObject">Объект метаданных.</param>
        /// <returns></returns>
        protected IMetadataObject GetMetadataObject(T metadataObject)
        {
            //проверяем наличие определения интерфейса метаданных.
            this.TypeDefinition.CheckIsMetadataObject();

            //получаем экземпляр информации о метаданных объекта.
            object          metadataObj          = metadataObject;
            IMetadataObject metadataObjInterface = (IMetadataObject)metadataObj;

            //возвращаем интерфейс метаданных.
            return(metadataObjInterface);
        }
Exemplo n.º 14
0
		/// <summary>
		///     Initializes a new instance.
		/// </summary>
		/// <param name="obj">The S# object the action belongs to.</param>
		/// <param name="method">The CLR method the metadata should be provided for.</param>
		/// <param name="name">The name of the method; if <c>null</c>, the method's CLR name is used.</param>
		internal ActionMetadata(IMetadataObject obj, MethodInfo method, string name = null)
			: base(obj, method, name)
		{
			Requires.That(HasImplementation, () => method, "Transition actions must have an implementation.");
			Requires.That(!CanBeAffectedByFaultEffects, () => method, "Transition actions must not be sensitive to fault effects.");
			Requires.That(method.GetParameters().Length == 0, () => method, "A transition action cannot take any parameters.");
			Requires.That(method.ReturnType == typeof(void), () => method, "A transition action must not return a value.");

			_delegate = (Action)CreateDelegate(typeof(Action));
			_transition = new Lazy<IEnumerable<TransitionMetadata>>(
				() => DeclaringObject.StateMachine.Transitions.Where(transition => transition.Action == this).ToArray());
		}
Exemplo n.º 15
0
 void CompareNodeChildren(IMetadataObject original, IMetadataObject @new, IList<MetadataTreeEntryChanges> changes, Stack<string> stack, ChildPropertyInfo childProperty)
 {
     using (var enumerator = new TwoSequenceEnumerator<IMetadataObject>(
         childProperty.Accessor(original),
         childProperty.Accessor(@new)))
     {
         while (!enumerator.BothCompleted)
         {
             CompareNodeChildren(changes, stack, enumerator);
         }
     }
 }
Exemplo n.º 16
0
        /// <summary>
        /// Gets the path to the data file for a node.
        /// </summary>
        /// <param name="source">The node.</param>
        /// <returns>A <see cref="string"/> value containing the path to the data file.</returns>
        internal static string GetDataPath(this IMetadataObject source)
        {
            var result = new StringBuilder();

            GetFolderPath(source, result);
            if (result.Length > 0)
            {
                result.Append('/');
            }
            result.Append(FileSystemStorage.DataFile);
            return(result.ToString());
        }
Exemplo n.º 17
0
        /// <summary>
        /// Flattens the specified source and its nested children.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <returns>An enumerable containing the source and its nested children.</returns>
        internal static IEnumerable <IMetadataObject> Flatten(this IMetadataObject source)
        {
            yield return(source);

            foreach (var child in source.Children)
            {
                foreach (var flattened in child.Flatten())
                {
                    yield return(flattened);
                }
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MetadataTreeEntryChanges"/> class.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="status">The change type.</param>
        /// <param name="old">The old value.</param>
        /// <param name="new">The new value.</param>
        /// <exception cref="ArgumentNullException">old</exception>
        public MetadataTreeEntryChanges(string path, ChangeKind status, IMetadataObject old = null, IMetadataObject @new = null)
        {
            Path   = path ?? throw new ArgumentNullException(nameof(path));
            Status = status;

            if (old == null && @new == null)
            {
                throw new ArgumentNullException($"{nameof(old)} and {nameof(@new)}");
            }

            Old = old;
            New = @new;
        }
Exemplo n.º 19
0
        /// <inheritdoc />
        public void AttachToParent(IMetadataObject parent)
        {
            if (parent == null)
            {
                throw new ArgumentNullException(nameof(parent));
            }
            if (Parent != null && Parent != parent)
            {
                throw new NotSupportedException("A single metadata object cannot be attached to two different parents.");
            }

            Parent = parent;
        }
Exemplo n.º 20
0
        void AttachChildrenToParentIfNeeded(IMetadataObject parent)
        {
            if (_parentAttachedInChildren || _children == null)
            {
                return;
            }

            foreach (var child in _children)
            {
                child.AttachToParent(parent);
            }
            _parentAttachedInChildren = true;
        }
Exemplo n.º 21
0
        internal static int GetHashCode(IMetadataObject metadataObject)
        {
            string text = string.Format(CultureInfo.InvariantCulture, AdomdUtils.MetadataHashCodeTemplate, new object[]
            {
                metadataObject.Connection.GetHashCode().ToString(CultureInfo.InvariantCulture),
                metadataObject.SessionId,
                metadataObject.Catalog,
                metadataObject.CubeName,
                metadataObject.Type.GetHashCode(),
                metadataObject.UniqueName
            });

            return(text.GetHashCode());
        }
Exemplo n.º 22
0
        object ProcessProperty(IMetadataObject node, string name, Type argumentType, object fallback)
        {
            var path           = node.GetDataPath();
            var propertyChange = _changes[path].FirstOrDefault(c => c.Property.Name.Equals(name, StringComparison.OrdinalIgnoreCase));

            if (propertyChange != null)
            {
                return(propertyChange.MergeValue.ToObject(argumentType, _serializer.Value));
            }
            else
            {
                return(fallback is ICloneable cloneable?cloneable.Clone() : fallback);
            }
        }
Exemplo n.º 23
0
        /// <summary>
        /// Gets the root repository of the specified node.
        /// </summary>
        /// <param name="node">The node.</param>
        /// <returns>The root <see cref="IMetadataObject"/> instance.</returns>
        /// <exception cref="ArgumentNullException">node</exception>
        internal static IMetadataObject Root(this IMetadataObject node)
        {
            if (node == null)
            {
                throw new ArgumentNullException(nameof(node));
            }

            while (node.Parent != null)
            {
                node = node.Parent;
            }

            return(node);
        }
Exemplo n.º 24
0
		/// <summary>
		///     Initializes a new instance.
		/// </summary>
		/// <param name="obj">The S# object the affected method belongs to.</param>
		/// <param name="affectedMethod">The metadata of the S# method that should be affected by the fault injector.</param>
		internal MethodBehaviorCollection(IMetadataObject obj, MethodMetadata affectedMethod)
		{
			Requires.NotNull(obj, () => obj);
			Requires.NotNull(affectedMethod, () => affectedMethod);

			_object = obj;
			AffectedMethod = affectedMethod;
			FaultEffects = Enumerable.Empty<FaultEffectMetadata>();
			FaultInjections = Enumerable.Empty<FaultInjection>().ToArray();

			// Create and inject the intended behavior now; we do that as early as possible so that all
			// methods can be called reliably in the model initialization phase
			IntendedBehavior = new IntendedBehavior(_object, affectedMethod);
			IntendedBehavior.Bind();
		}
Exemplo n.º 25
0
        /// <summary>
        /// Gets whether two objects store the same value.
        /// </summary>
        /// <param name="old">The old.</param>
        /// <param name="new">The new.</param>
        /// <returns><code>true</code> is the objects contain the same property value.</returns>
        /// <exception cref="ArgumentNullException">
        /// old
        /// or
        /// new
        /// </exception>
        public bool AreSame(IMetadataObject old, IMetadataObject @new)
        {
            if (old == null)
            {
                throw new ArgumentNullException(nameof(old));
            }
            if (@new == null)
            {
                throw new ArgumentNullException(nameof(@new));
            }

            var oldValue = Accessor(old);
            var newValue = Accessor(@new);

            return(oldValue == newValue || (oldValue?.Equals(newValue) ?? false));
        }
Exemplo n.º 26
0
        /// <summary>
        /// Обновляет существующий объект в базе данных.
        /// </summary>
        /// <param name="metadataObject">Объект метаданных.</param>
        /// <returns></returns>
        protected bool UpdateObject(T metadataObject)
        {
            if (metadataObject == null)
            {
                throw new ArgumentNullException("metadataObject");
            }

            string tableName = this.GetTableName(metadataObject);

            if (String.IsNullOrEmpty(tableName))
            {
                throw new Exception(String.Format("Не удалось определить конечную таблицу для объекта {0} типа {1}", metadataObject.ToString(), metadataObject.GetType().Name));
            }

            DBObjectDistributedTable table        = this.MetadataAdapter.TableActivator.GetDistributedTable(this.DBSchemaAdapter, tableName);
            MetadataQueryBuilder     queryBuilder = new MetadataQueryBuilder(table.TablePartition.Table, this.TypeDefinition);

            //приводим объект к типу метаданных.
            IMetadataObject metadata = this.GetMetadataObject(metadataObject);

            if (metadata.ID == 0)
            {
                throw new ArgumentNullException("metadata.ID", "Не передан идентификатор объекта.");
            }

            //формируем условие обновления объекта по идентификатору.
            string identityCondition = string.Format("[ID] = {1}", table.TablePartition.Table.IdentityColumn.Name, metadata.ID);

            //запрос обновления объекта метаданных.
            string updateQuery = @"
{UpdateQuery}
WHERE {IdentityCondition}
SELECT @@ROWCOUNT"
                                 .ReplaceKey("UpdateQuery", queryBuilder.UpdateQuery)
                                 .ReplaceKey("IdentityCondition", identityCondition)
            ;


            //формируем параметры обновления, соответствующие значениям свойств объекта.
            DBCollection <SqlParameter> updateParams = this.CreateInsertParameters(metadataObject);

            //выполняем запрос.
            int affectedRowsCount = this.DataAdapter.GetScalarValue <int>(updateQuery, updateParams.ToArray());

            return(affectedRowsCount > 0);
        }
Exemplo n.º 27
0
 void RemoveNode(IMetadataObject left, IList<MetadataTreeEntryChanges> changed, Stack<string> stack)
 {
     var path = stack.ToDataPath();
     changed.Add(new MetadataTreeEntryChanges(path, ChangeKind.Deleted, old: left));
     var dataAccessor = _modelDataProvider.Get(left.GetType());
     foreach (var childProperty in dataAccessor.ChildProperties)
     {
         stack.Push(childProperty.Name);
         foreach (var child in left.Children)
         {
             stack.Push(child.Id.ToString());
             RemoveNode(child, changed, stack);
             stack.Pop();
         }
         stack.Pop();
     }
 }
Exemplo n.º 28
0
        void CompareNode(IMetadataObject original, IMetadataObject @new, IList<MetadataTreeEntryChanges> changes, Stack<string> stack)
        {
            var accessor = _modelDataProvider.Get(original.GetType());
            UpdateNodeIfNeeded(original, @new, stack, accessor, changes);
            foreach (var childProperty in accessor.ChildProperties)
            {
                if (!childProperty.ShouldVisitChildren(original) && !childProperty.ShouldVisitChildren(@new))
                {
                    // Do not visit children if they were not generated.
                    // This means that they were not modified!
                    continue;
                }

                stack.Push(childProperty.FolderName);
                CompareNodeChildren(original, @new, changes, stack, childProperty);
                stack.Pop();
            }
        }
Exemplo n.º 29
0
 static void GetFolderPath(IMetadataObject node, StringBuilder builder)
 {
     if (node.Parent != null)
     {
         GetFolderPath(node.Parent, builder);
         var childProperty = node.Parent.DataAccessor.ChildProperties.Single(p => p.ItemType.IsInstanceOfType(node));
         if (builder.Length > 0)
         {
             builder.Append('/');
         }
         builder.Append(childProperty.Name);
         builder.Append('/');
     }
     if (!(node is IObjectRepository))
     {
         builder.Append(node.Id);
     }
 }
Exemplo n.º 30
0
        /// <inheritdoc />
        public IMetadataObject With(IMetadataObject source, IPredicateReflector predicate)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            if (predicate == null)
            {
                throw new ArgumentNullException(nameof(predicate));
            }

            var newInstance = DeepClone(
                source.Repository,
                predicate.ProcessArgument,
                predicate.GetChildChanges,
                n => n.IsParentOf(source));

            return(newInstance.TryGetFromGitPath(source.GetDataPath()));
        }
Exemplo n.º 31
0
 IEnumerable <TChild> GetValueFromFactory(IMetadataObject parent)
 {
     if (_factory != null)
     {
         return(_factory(parent) ?? throw new NotSupportedException(_nullReturnedValueExceptionMessage));
     }
     else if (_factoryWithRepo != null)
     {
         var objectRepository = (AbstractObjectRepository)parent.Repository;
         return(objectRepository._repositoryProvider.Execute(
                    objectRepository._repositoryDescription,
                    repository =>
         {
             var nodes = _factoryWithRepo(parent, repository) ?? throw new NotSupportedException(_nullReturnedValueExceptionMessage);
             return nodes.Cast <TChild>();
         }));
     }
     throw new NotSupportedException("Factory cannot be null.");
 }
Exemplo n.º 32
0
        /// <inheritdoc/>
        public object ProcessArgument(IMetadataObject instance, string name, Type argumentType, object fallback = null)
        {
            if (instance == null)
            {
                throw new ArgumentNullException(nameof(instance));
            }
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }
            if (argumentType == null)
            {
                throw new ArgumentNullException(nameof(argumentType));
            }

            var matchingPredicate = _reflectors.FirstOrDefault(r => r.Instance == instance);

            if (matchingPredicate != null)
            {
                return(matchingPredicate.ProcessArgument(instance, name, argumentType, fallback));
            }
            return(fallback is ICloneable cloneable?cloneable.Clone() : fallback);
        }
Exemplo n.º 33
0
        /// <summary>
        /// Determines whether this node is a parent of the specified instance.
        /// </summary>
        /// <param name="source">The source.</param>
        /// <param name="instance">The instance.</param>
        /// <returns>
        ///   <c>true</c> if the node is a parent of the specified instance; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsParentOf(this IMetadataObject source, IMetadataObject instance)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }
            if (instance == null)
            {
                throw new ArgumentNullException(nameof(instance));
            }

            var node = instance.Parent;

            while (node != null)
            {
                if (node == source)
                {
                    return(true);
                }
                node = node.Parent;
            }
            return(false);
        }
Exemplo n.º 34
0
        /// <summary>
        /// Обновляет существующий объект в базе данных.
        /// </summary>
        /// <param name="metadataObject">Объект метаданных.</param>
        /// <returns></returns>
        protected bool UpdateObject(T metadataObject)
        {
            if (metadataObject == null)
            {
                throw new ArgumentNullException("metadataObject");
            }

            //приводим объект к типу метаданных.
            IMetadataObject metadata = this.GetMetadataObject(metadataObject);

            if (metadata.ID == 0)
            {
                throw new ArgumentNullException("metadata.ID", "Не передан идентификатор объекта.");
            }

            //формируем условие обновления объекта по идентификатору.
            string identityCondition = string.Format("[ID] = {1}", this.IdentityColumn.Name, metadata.ID);

            //запрос обновления объекта метаданных.
            string updateQuery = @"
{UpdateQuery}
WHERE {IdentityCondition}
SELECT @@ROWCOUNT"
                                 .ReplaceKey("UpdateQuery", this.UpdateQuery)
                                 .ReplaceKey("IdentityCondition", identityCondition)
            ;


            //формируем параметры обновления, соответствующие значениям свойств объекта.
            DBCollection <SqlParameter> updateParams = this.CreateInsertParameters(metadataObject);

            //выполняем запрос.
            int affectedRowsCount = this.DataAdapter.GetScalarValue <int>(updateQuery, updateParams.ToArray());

            return(affectedRowsCount > 0);
        }
Exemplo n.º 35
0
		/// <summary>
		///     Initializes a new instance.
		/// </summary>
		/// <param name="obj">The <see cref="IMetadataObject" /> the exception should be raised for.</param>
		/// <param name="message">The message giving further details about the exception.</param>
		public MetadataException(IMetadataObject obj, string message)
			: base(String.Format("{0} The 'Object' property contains the metadata object the exception was raised for.", message))
		{
			Requires.NotNull(obj, () => obj);
			Object = obj;
		}
		/// <summary>
		///     Initializes a new instance.
		/// </summary>
		/// <param name="obj">The S# object the method belongs to.</param>
		/// <param name="method">The metadata of the method the fault injection belongs to.</param>
		/// <param name="faultEffect">The fault effect that should be injected deterministically.</param>
		public DeterministicFaultInjection(IMetadataObject obj, MethodMetadata method, FaultEffectMetadata faultEffect)
			: base(obj, method)
		{
			Requires.NotNull(faultEffect, () => faultEffect);
			FaultEffect = faultEffect;
		}
Exemplo n.º 37
0
 public void AddMetadataObject(IMetadataObject metadataObject, Action<int> SetAddObjectId)
 {
     this._ServiceProxy.BeginAddMetadataObject(metadataObject, delegate(IAsyncResult ar)
     {
         int objectId = this._ServiceProxy.EndAddMetadataObject(ar);
         SetAddObjectId(objectId);
     }, null);
 }
Exemplo n.º 38
0
 public VmQuotationBase(IMetadataObject metadataObject)
     : base(metadataObject)
 {
 }
Exemplo n.º 39
0
 public VmBase(IMetadataObject metadataObject)
 {
     this._MetadataObject = metadataObject;
 }