public ContextEntityTypesProvider(IMetadataProvider metadataProvider) { var testMetadata = metadataProvider.GetMetadataSet<TestCaseMetadataIdentity>().Metadata.Values.OfType<TestCaseMetadataElement>().ToArray(); var features = GetContextFeatures(testMetadata); _entitiesByContext = features.GroupBy(x => x.Context, x => x.Data) .ToDictionary(x => x.Key, x => x.SelectMany(y => y).Select(y => y.GetType()).Distinct().ToArray()); }
protected CommandContextBase(Command command, BuilderContext builderContext) { CurrentCommand = command; BuildParameters = builderContext.Parameters; ResultEntry = new CommandResultEntry(); MetadataProvider = builderContext.MetadataProvider; }
public UpdateMetadataCommandTests() { _metadataProvider = Substitute.For<IMetadataProvider>(); _progressManager = Substitute.For<IProgressManagerViewModel>(); _busyProvider = Substitute.For<IBusyProvider>(); _command = new UpdateMetadataCommand(_metadataProvider, _progressManager, _busyProvider); }
SetRandomMetadata ( IMetadataProvider oMetadataProvider, Boolean bSetMetadataValues, Boolean bSetTag, Int32 iSeed ) { KeyValuePair<String, Object> [] aoRandomMetadata; Object oRandomTag; GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag); if (bSetMetadataValues) { foreach (KeyValuePair<String, Object> oRandomMetadata in aoRandomMetadata) { oMetadataProvider.SetValue( oRandomMetadata.Key, oRandomMetadata.Value); } } if (bSetTag) { oMetadataProvider.Tag = oRandomTag; } }
/// <summary> /// Loads the signature. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> public void LoadSignature(IMetadataProvider provider, TokenTypes token) { byte[] buffer; int index = 0; provider.Read(token, out buffer); ParseSignature(buffer, ref index); Debug.Assert(index == buffer.Length, @"Signature parser didn't complete."); }
public EdmModelBuilder(IMetadataProvider metadataProvider) { if (metadataProvider == null) { throw new ArgumentNullException("metadataProvider"); } _metadataProvider = metadataProvider; }
public PdbWriter(string fileName, IMetadataProvider metadataProvider) { this.pdb = new ISymUnmanagedWriter2(); this.metadataProvider = metadataProvider; this.documentWriters = new Dictionary<string, ISymUnmanagedDocumentWriter>(); this.pdb.Initialize(new Metadata(metadataProvider), fileName, pIStream: null, fFullBuild: true); }
protected TestBase(ITestFixture fixture) { this.dte = fixture.Dte; this.metadataProvider = fixture.Provider; this.isRoslyn = fixture is RoslynFixture; this.isCodeDom = fixture is CodeDomFixture; }
/// <summary> /// Loads the signature. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> public Signature(IMetadataProvider provider, TokenTypes token) { SignatureReader reader = new SignatureReader(provider.ReadBlob(token)); this.ParseSignature(reader); Debug.Assert(reader.Index == reader.Length, @"Signature parser didn't complete."); this.token = token; }
public EventBus(IMessageSender messageSender, IRoutingKeyProvider routingKeyProvider, IMetadataProvider metadataProvider) { this.messageSender = messageSender; this.routingKeyProvider = routingKeyProvider; this.metadataProvider = metadataProvider; this.logger = LogManager.GetLogger("ThinkNet"); }
private static IEdmModel BuildModel(IMetadataProvider provider, Uri contextId) { var builder = new EdmModelBuilder(provider); var model = builder.Build(contextId); model.Dump(); return model; }
/// <summary> /// Parses the specified provider. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> /// <returns></returns> public static LocalVariableSignature Parse(IMetadataProvider provider, TokenTypes token) { byte[] buffer; int index = 0; provider.Read(token, out buffer); LocalVariableSignature sig = new LocalVariableSignature(); sig.ParseSignature(buffer, ref index); Debug.Assert(index == buffer.Length, @"Signature parser didn't complete."); return sig; }
public void OnSetup() { var customizedMetadataDto = CreateCustomizedMetadataDto (); _metadataProvider = new PatientProfileDto { MetadataDto = customizedMetadataDto }; var defaultMetadataDto = CreateDefaultMetadataDto (); var metadataServiceMock = new Mock<IMetadataService> (); metadataServiceMock.Setup ( x => x.GetMetadata ( It.IsAny<Type> () ) ).Returns ( defaultMetadataDto ); _metadataService = metadataServiceMock.Object; }
private static DbModel BuildModel(IMetadataProvider metadataProvider, IClrTypeProvider clrTypeProvider) { BoundedContextElement context; metadataProvider.TryGetMetadata(BuildContextId(), out context); var configurator = new DbModelBuilderConfigurator(metadataProvider, clrTypeProvider); var builder = configurator.Configure(context); return(builder.Build(EffortProvider)); }
public GenerationController(DTE dte, IMetadataProvider metadataProvider, SolutionMonitor solutionMonitor, TemplateController templateController, EventQueue eventQueue) { this.dte = dte; this.metadataProvider = metadataProvider; this.templateController = templateController; solutionMonitor.FileAdded += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path); solutionMonitor.FileChanged += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Render, args.Path); solutionMonitor.FileDeleted += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Delete, args.Path); solutionMonitor.FileRenamed += (sender, args) => eventQueue.Enqueue(Render, GenerationType.Rename, args.OldPath, args.NewPath); }
private int GetDefaultOrder(IMetadataProvider provider) { var hasOrder = provider as IHasOrder; if (hasOrder != null) { return(hasOrder.Order); } return(0); }
private static TreeNode CreateDatabaseNode(IMetadataProvider provider, ConnectionInfo connection) { TreeNode node = new TreeNodeWithConnectionInfo(provider.Name, connection); node.SelectedImageKey = "Database"; node.ImageKey = "Database"; node.Tag = provider; node.Name = node.Text; return(node); }
public OperationsPrimaryProcessingJob( IMetadataProvider metadataProvider, IMessageFlowProcessorFactory messageFlowProcessorFactory, ISignInService signInService, IUserImpersonationService userImpersonationService, ITracer tracer) : base(signInService, userImpersonationService, tracer) { _metadataProvider = metadataProvider; _messageFlowProcessorFactory = messageFlowProcessorFactory; }
public CommandBus(IMessageSender messageSender, ICommandResultManager commandResultManager, IRoutingKeyProvider routingKeyProvider, IMetadataProvider metadataProvider) { this.messageSender = messageSender; this.commandResultManager = commandResultManager; this.routingKeyProvider = routingKeyProvider; this.metadataProvider = metadataProvider; this.logger = LogManager.GetLogger("ThinkNet"); }
/// <summary> /// Writes the assembly processor table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteAssemblyProcessorTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { AssemblyProcessorRow row; WriteTable(TokenTypes.AssemblyProcessor, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.Processor); }); }
/// <summary> /// Writes the module ref table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteModuleRefTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { ModuleRefRow row; WriteTable(TokenTypes.ModuleRef, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.NameStringIdx); }); }
/// <summary> /// Loads the signature. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> public void LoadSignature(ISignatureContext context, IMetadataProvider provider, TokenTypes token) { byte[] buffer; provider.Read(token, out buffer); int index = 0; this.ParseSignature(context, buffer, ref index); Debug.Assert(index == buffer.Length, @"Signature parser didn't complete."); this.token = token; }
/// <summary> /// Writes the type spec table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteTypeSpecTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { TypeSpecRow row; WriteTable(TokenTypes.TypeSpec, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.SignatureBlobIdx); }); }
/// <summary> /// Writes the standalone sig table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteStandaloneSigTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { StandAloneSigRow row; WriteTable(TokenTypes.StandAloneSig, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.SignatureBlobIdx); }); }
public CachedEntityReader( IMetadataProvider metadataProvider, IDatabase database, ICacheProvider cacheProvider) : base(metadataProvider, database) { cacheProvider.ThrowIfNull(); Cache = cacheProvider; _keyGenerator = new CacheKeyGenerator <TEntity>(); }
/// <summary> /// Parses the specified provider. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> /// <returns></returns> public static MethodSignature Parse(IMetadataProvider provider, TokenTypes token) { byte[] buffer; int index = 0; provider.Read(token, out buffer); MethodSignature msig = new MethodSignature(token); msig.ParseSignature(buffer, ref index); Debug.Assert(index == buffer.Length, @"Signature parser didn't complete."); return(msig); }
/// <summary> /// Parses the specified provider. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> /// <returns></returns> public static LocalVariableSignature Parse(IMetadataProvider provider, TokenTypes token) { byte[] buffer; int index = 0; provider.Read(token, out buffer); LocalVariableSignature sig = new LocalVariableSignature(); sig.ParseSignature(buffer, ref index); Debug.Assert(index == buffer.Length, @"Signature parser didn't complete."); return(sig); }
/// <summary> /// Writes the generic param constraint table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteGenericParamConstraintTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { GenericParamConstraintRow row; WriteTable(TokenTypes.GenericParamConstraint, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.OwnerTableIdx); metadataWriter.WriteTypeDefOrRefIndex(row.ConstraintTableIdx); }); }
/// <summary> /// Writes the method spec table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteMethodSpecTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { MethodSpecRow row; WriteTable(TokenTypes.MethodSpec, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.WriteMethodDefOrRefIndex(row.MethodTableIdx); metadataWriter.Write(row.InstantiationBlobIdx); }); }
/// <summary> /// Writes the nested class table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteNestedClassTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { NestedClassRow row; WriteTable(TokenTypes.NestedClass, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.NestedClassTableIdx); metadataWriter.Write(row.EnclosingClassTableIdx); }); }
/// <summary> /// Writes the field RVA table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteFieldRVATable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { FieldRVARow row; WriteTable(TokenTypes.FieldRVA, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.Rva); metadataWriter.Write(row.FieldTableIdx); }); }
/// <summary> /// Writes the property map table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WritePropertyMapTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { PropertyMapRow row; WriteTable(TokenTypes.PropertyMap, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.ParentTableIdx); metadataWriter.Write(row.PropertyTableIdx); }); }
/// <summary> /// Writes the event map table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteEventMapTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { EventMapRow row; WriteTable(TokenTypes.EventMap, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.TypeDefTableIdx); metadataWriter.Write(row.EventListTableIdx); }); }
/// <summary> /// Writes the interfaceimpl table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteInterfaceImplTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { InterfaceImplRow row; WriteTable(TokenTypes.InterfaceImpl, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.ClassTableIdx); metadataWriter.WriteTypeDefOrRefIndex(row.InterfaceTableIdx); }); }
/// <summary> /// Writes the field marshal table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteFieldMarshalTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { FieldMarshalRow row; WriteTable(TokenTypes.FieldMarshal, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.WriteHasFieldMarshalIndex(row.ParentTableIdx); metadataWriter.Write(row.NativeTypeBlobIdx); }); }
internal EventStoreStub(Action<T, string, DateTime> onSave) { this.onSave = onSave; this.metadataProvider = new StandardMetadataProvider(); var constructor = typeof(T).GetConstructor(new[] { typeof(Guid), typeof(IEnumerable<IVersionedEvent>) }); if (constructor == null) { throw new InvalidCastException( "Type T must have a constructor with the following signature: .ctor(Guid, IEnumerable<IVersionedEvent>)"); } this.entityFactory = (id, events) => (T)constructor.Invoke(new object[] { id, events }); }
public OperationsFinalProcessingJob( IMetadataProvider metadataProvider, IMessageFlowProcessorFactory messageFlowProcessorFactory, ISignInService signInService, IUserImpersonationService userImpersonationService, ITracer tracer) : base(signInService, userImpersonationService, tracer) { _metadataProvider = metadataProvider; _messageFlowProcessorFactory = messageFlowProcessorFactory; _firstFaultTolerantStageSetting = new Lazy <MessageProcessingStage>(EvaluateFirstFaultTolerantStage); }
private void AddPropertiesToNode(IMetadataProvider provider, TreeNode entityNode, IEnumerable <Property> properties) { foreach (Property property in properties.OrderBy(c => c.Name)) { string name = DocumentationBuilder.ToNodeText(property); var imageKey = ImageKeys.GetImageKey(property); TreeNode node = CreateNode(provider, name, imageKey, property); node.ToolTipText = DocumentationBuilder.ToToolTip(property, property); node.NodeFont = NodeFont(property); entityNode.Nodes.Add(node); } }
/// <summary> /// Reads an (optional) custom modifier /// </summary> /// <param name="provider">The provider.</param> /// <param name="buffer">The buffer to read the modifier From.</param> /// <param name="index">The start index, where the modifier is expected.</param> /// <returns></returns> public static bool ReadCustomMod(IMetadataProvider provider, byte[] buffer, ref int index) { bool result = (buffer[index] == (byte)CilElementType.Required || buffer[index] == (byte)CilElementType.Optional); if (result) { index++; ReadTypeDefOrRefEncoded(provider, buffer, ref index); Debug.WriteLine("Skipping CilElementType.Required or CilElementType.Optional."); } return(result); }
/// <summary> /// Writes the field layout table. /// </summary> /// <param name="metadataSource">The metadata source.</param> /// <param name="metadataWriter">The metadata writer.</param> private static void WriteFieldLayoutTable(IMetadataProvider metadataSource, MetadataBuilderStage metadataWriter) { FieldLayoutRow row; WriteTable(TokenTypes.FieldLayout, metadataSource, token => { metadataSource.Read(token, out row); metadataWriter.Write(row.Offset); metadataWriter.Write(row.Field); }); }
public override GameMetadata DownloadGameData(string gameName, string id, IMetadataProvider provider) { CallCount++; if (DownloadDataHandler != null) { return(DownloadDataHandler(gameName, id, provider)); } else { return(base.DownloadGameData(gameName, id, provider)); } }
private void WriteObjectMetadata(IMetadataProvider obj) { if (obj == null) { return; } foreach (var metadata in obj.GetMetadata()) { _storageInstance.Writer.WriteElementString(metadata.Name, metadata.Value != null ? metadata.Value.ToString() : string.Empty); } }
public OperationsFinalProcessingJob( IMetadataProvider metadataProvider, IMessageFlowProcessorFactory messageFlowProcessorFactory, ISignInService signInService, IUserImpersonationService userImpersonationService, ITracer tracer) : base(signInService, userImpersonationService, tracer) { _metadataProvider = metadataProvider; _messageFlowProcessorFactory = messageFlowProcessorFactory; _firstFaultTolerantStageSetting = new Lazy<MessageProcessingStage>(EvaluateFirstFaultTolerantStage); }
private static Documentation EntityDocumentation(IMetadataProvider provider, Entity entity) { var builder = new StringBuilder(); builder.AppendName(entity.FullName); builder.Append($"Base type: {entity.BaseType}\r\n"); builder.AppendAccessControl(provider.ConnectionInfo, entity); builder.AppendSummaryParagraph(entity.Summary); var docs = builder.ToString(); return(new Documentation("Entity", docs)); }
public given_an_empty_event_log() { this.tableName = "AzureEventLogFixture" + new Random((int)DateTime.Now.Ticks).Next(); var settings = InfrastructureSettings.Read("Settings.xml").EventSourcing; this.account = CloudStorageAccount.Parse(settings.ConnectionString); this.eventA = new EventA(); this.eventB = new EventB(); this.eventC = new EventC(); this.metadata = Mock.Of <IMetadataProvider>(x => x.GetMetadata(eventA) == new Dictionary <string, string> { { StandardMetadata.SourceId, eventA.SourceId.ToString() }, { StandardMetadata.SourceType, "SourceA" }, { StandardMetadata.Kind, StandardMetadata.EventKind }, { StandardMetadata.AssemblyName, "A" }, { StandardMetadata.Namespace, "Namespace" }, { StandardMetadata.FullName, "Namespace.EventA" }, { StandardMetadata.TypeName, "EventA" }, } && x.GetMetadata(eventB) == new Dictionary <string, string> { { StandardMetadata.SourceId, eventB.SourceId.ToString() }, { StandardMetadata.SourceType, "SourceB" }, { StandardMetadata.Kind, StandardMetadata.EventKind }, { StandardMetadata.AssemblyName, "B" }, { StandardMetadata.Namespace, "Namespace" }, { StandardMetadata.FullName, "Namespace.EventB" }, { StandardMetadata.TypeName, "EventB" }, } && x.GetMetadata(eventC) == new Dictionary <string, string> { { StandardMetadata.SourceId, eventC.SourceId.ToString() }, { StandardMetadata.SourceType, "SourceC" }, { StandardMetadata.Kind, StandardMetadata.EventKind }, { StandardMetadata.AssemblyName, "B" }, { StandardMetadata.Namespace, "AnotherNamespace" }, { StandardMetadata.FullName, "AnotherNamespace.EventC" }, { StandardMetadata.TypeName, "EventC" }, }); this.serializer = new JsonTextSerializer(); this.writer = new AzureMessageLogWriter(this.account, this.tableName); this.sut = new AzureEventLogReader(this.account, this.tableName, new JsonTextSerializer()); this.startEnqueueTime = new DateTime(2012, 06, 30, 23, 59, 0, DateTimeKind.Utc); Save(eventA, startEnqueueTime); Save(eventB, startEnqueueTime.AddMinutes(5)); Save(eventC, startEnqueueTime.AddMinutes(6)); }
CheckRandomMetadata ( IMetadataProvider oMetadataProvider, Boolean bRandomMetadataExpected, Boolean bRandomTagExpected, Int32 iSeed ) { KeyValuePair <String, Object> [] aoRandomMetadata; Object oRandomTag; GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag); foreach (KeyValuePair <String, Object> oRandomMetadata in aoRandomMetadata) { String sRandomKey = oRandomMetadata.Key; Object oRandomValue = oRandomMetadata.Value; if (bRandomMetadataExpected) { Assert.IsTrue(oMetadataProvider.ContainsKey(sRandomKey)); Object oValue; Assert.IsTrue(oMetadataProvider.TryGetValue( sRandomKey, (oRandomValue == null) ? typeof(Object) : oRandomValue.GetType(), out oValue )); CheckMetadataValue(oRandomValue, oValue); } else { Assert.IsFalse(oMetadataProvider.ContainsKey(sRandomKey)); } } if (bRandomTagExpected) { CheckMetadataValue(oRandomTag, oMetadataProvider.Tag); } else { Assert.IsNull(oMetadataProvider.Tag); } }
/// <summary> /// Creates an instance of a specific heap type. /// </summary> /// <param name="provider">The provider buffer, which contains the heap.</param> /// <param name="type">The type of the heap to create.</param> /// <param name="metadata">The metadata.</param> /// <param name="offset">The offset into the buffer, where the heap starts.</param> /// <param name="size">The size of the heap in bytes.</param> /// <returns>An instance of the requested heap type.</returns> /// <exception cref="System.ArgumentException">An invalid heap type was requested.</exception> public static Heap CreateHeap(IMetadataProvider provider, HeapType type, byte[] metadata, int offset, int size) { switch (type) { case HeapType.String: return new StringHeap(metadata, offset, size); case HeapType.Guid: return new GuidHeap(metadata, offset, size); case HeapType.Blob: return new BlobHeap(metadata, offset, size); case HeapType.UserString: return new UserStringHeap(metadata, offset, size); case HeapType.Tables: return new TableHeap(provider, metadata, offset, size); } throw new ArgumentException(@"Invalid heap type.", @"type"); }
public FactsReplicator( ITracer tracer, IReplicationSettings replicationSettings, IMetadataProvider metadataProvider, IFactProcessorFactory factProcessorFactory, IComparer<Type> factTypePriorityComparer) { _tracer = tracer; _replicationSettings = replicationSettings; _metadataProvider = metadataProvider; _factProcessorFactory = factProcessorFactory; _factTypePriorityComparer = factTypePriorityComparer; }
public given_an_empty_event_log() { this.tableName = "AzureEventLogFixture" + new Random((int)DateTime.Now.Ticks).Next(); var settings = InfrastructureSettings.Read("Settings.xml").EventSourcing; this.account = CloudStorageAccount.Parse(settings.ConnectionString); this.eventA = new EventA(); this.eventB = new EventB(); this.eventC = new EventC(); this.metadata = Mock.Of<IMetadataProvider>(x => x.GetMetadata(eventA) == new Dictionary<string, string> { { StandardMetadata.SourceId, eventA.SourceId.ToString() }, { StandardMetadata.SourceType, "SourceA" }, { StandardMetadata.Kind, StandardMetadata.EventKind }, { StandardMetadata.AssemblyName, "A" }, { StandardMetadata.Namespace, "Namespace" }, { StandardMetadata.FullName, "Namespace.EventA" }, { StandardMetadata.TypeName, "EventA" }, } && x.GetMetadata(eventB) == new Dictionary<string, string> { { StandardMetadata.SourceId, eventB.SourceId.ToString() }, { StandardMetadata.SourceType, "SourceB" }, { StandardMetadata.Kind, StandardMetadata.EventKind }, { StandardMetadata.AssemblyName, "B" }, { StandardMetadata.Namespace, "Namespace" }, { StandardMetadata.FullName, "Namespace.EventB" }, { StandardMetadata.TypeName, "EventB" }, } && x.GetMetadata(eventC) == new Dictionary<string, string> { { StandardMetadata.SourceId, eventC.SourceId.ToString() }, { StandardMetadata.SourceType, "SourceC" }, { StandardMetadata.Kind, StandardMetadata.EventKind }, { StandardMetadata.AssemblyName, "B" }, { StandardMetadata.Namespace, "AnotherNamespace" }, { StandardMetadata.FullName, "AnotherNamespace.EventC" }, { StandardMetadata.TypeName, "EventC" }, }); this.serializer = new JsonTextSerializer(); this.writer = new AzureMessageLogWriter(this.account, this.tableName); this.sut = new AzureEventLogReader(this.account, this.tableName, new JsonTextSerializer()); this.startEnqueueTime = new DateTime(2012, 06, 30, 23, 59, 0, DateTimeKind.Utc); Save(eventA, startEnqueueTime); Save(eventB, startEnqueueTime.AddMinutes(5)); Save(eventC, startEnqueueTime.AddMinutes(6)); }
//************************************************************************* // Method: CheckRandomMetadata() // /// <summary> /// Checks the random metadata and Tag values on an object that implements /// <see cref="IMetadataProvider" />. /// </summary> /// /// <param name="oMetadataProvider"> /// Object to check random metadata and Tag values on. /// </param> /// /// <param name="bRandomMetadataExpected"> /// true if the metadata was set with <see cref="SetRandomMetadata" />, /// false if the metadata was left empty. /// </param> /// /// <param name="bRandomTagExpected"> /// true if the Tag was set with <see cref="SetRandomMetadata" />, /// false if the Tag was left as null. /// </param> /// /// <param name="iSeed"> /// Seed to use for the random number generator. /// </param> /// /// <remarks> /// This method checks the random metadata and Tag values that were set /// with <see cref="SetRandomMetadata" />. /// </remarks> //************************************************************************* public static void CheckRandomMetadata( IMetadataProvider oMetadataProvider, Boolean bRandomMetadataExpected, Boolean bRandomTagExpected, Int32 iSeed ) { KeyValuePair<String, Object> [] aoRandomMetadata; Object oRandomTag; GetRandomMetadata(iSeed, out aoRandomMetadata, out oRandomTag); foreach (KeyValuePair<String, Object> oRandomMetadata in aoRandomMetadata) { String sRandomKey = oRandomMetadata.Key; Object oRandomValue = oRandomMetadata.Value; if (bRandomMetadataExpected) { Assert.IsTrue( oMetadataProvider.ContainsKey(sRandomKey) ); Object oValue; Assert.IsTrue( oMetadataProvider.TryGetValue( sRandomKey, (oRandomValue == null) ? typeof(Object) : oRandomValue.GetType(), out oValue ) ); CheckMetadataValue(oRandomValue, oValue); } else { Assert.IsFalse( oMetadataProvider.ContainsKey(sRandomKey) ); } } if (bRandomTagExpected) { CheckMetadataValue(oRandomTag, oMetadataProvider.Tag); } else { Assert.IsNull(oMetadataProvider.Tag); } }
public CommonReplicationStrategy(IMetadataProvider metadataProvider, Type entityType) { Guard.AgainstNull(metadataProvider, "metadataProvider"); Guard.AgainstNull(entityType, "entityType"); Guard.AgainstViolation(!entityType.IsNullable() && !entityType.IsArray, "CommonReplicationStrategy is not applicable to nullable or array types"); this.entityType = entityType; memberDescriptions = metadataProvider.GetFieldsReplicationInfo(entityType) .Where(t => t.Behavior != ReplicationBehavior.Ignore) .Select(t => new MemberReplicationInfo(entityType, t)) .ToArray(); }
/// <summary> /// Computes the field offset. /// </summary> /// <param name="token">The token.</param> /// <param name="metadataProvider">The metadata provider.</param> /// <param name="architecture">The architecture.</param> /// <returns></returns> public static int ComputeFieldOffset(ISignatureContext context, TokenTypes token, IMetadataProvider metadataProvider, IArchitecture architecture) { Metadata.Tables.TypeDefRow typeDefinition; Metadata.Tables.TypeDefRow followingTypeDefinition; metadataProvider.Read(token, out typeDefinition); metadataProvider.Read(token + 1, out followingTypeDefinition); int result = 0; TokenTypes fieldList = typeDefinition.FieldList; while (fieldList != token) result += FieldSize(context, fieldList++, metadataProvider, architecture); return result; }
public DbModelFactory(IMetadataProvider metadataProvider, IClrTypeProvider clrTypeProvider) { if (metadataProvider == null) { throw new ArgumentNullException(nameof(metadataProvider)); } if (clrTypeProvider == null) { throw new ArgumentNullException(nameof(clrTypeProvider)); } _dbModelBuilderConfigurator = new DbModelBuilderConfigurator(metadataProvider, clrTypeProvider); _metadataProvider = metadataProvider; }
public static void Startup(TestContext context) { var connectionProperties = new Dictionary<string, string>(); //setup the initial parameters for data connection connectionProperties.Add("Provider", "SQLNCLI10"); connectionProperties.Add("Server", "localhost"); connectionProperties.Add("Database", "ScribeSampleRSSource"); connectionProperties.Add("UserName", "sa"); //encrypt the connection password using the shared key string encryptedPassword = Encryptor.Encrypt_AesManaged("sa", CryptoKey); connectionProperties.Add("Password", encryptedPassword); //open a new connection to the datasource _sysConnector.Connect(connectionProperties); //set an instance of the open metadata provider _metadataProvider = _sysConnector.GetMetadataProvider(); }
/// <summary> /// Fields the size. /// </summary> /// <param name="field">The field.</param> /// <param name="metadataProvider">The metadata provider.</param> /// <param name="architecture">The architecture.</param> /// <returns></returns> public static int FieldSize(ISignatureContext context, TokenTypes field, IMetadataProvider metadataProvider, IArchitecture architecture) { Metadata.Tables.FieldRow fieldRow; metadataProvider.Read(field, out fieldRow); FieldSignature signature = Signature.FromMemberRefSignatureToken(context, metadataProvider, fieldRow.SignatureBlobIdx) as FieldSignature; // If the field is another struct, we have to dig down and compute its size too. if (signature.Type.Type == CilElementType.ValueType) { TokenTypes valueTypeSig = ValueTokenTypeFromSignature(metadataProvider, fieldRow.SignatureBlobIdx); return ComputeTypeSize(context, valueTypeSig, metadataProvider, architecture); } int size, alignment; architecture.GetTypeRequirements(signature.Type, out size, out alignment); return size; }
private void CustomizeEntity(IMetadataProvider metadataProvider, Uri entityElementId) { EntityElement entityElement; if (!metadataProvider.TryGetMetadata(entityElementId, out entityElement)) { throw new ArgumentException(); } // ограничение для серверного paging PageSize = 100; // убрали ограничение, вернуть когда в ODATA появится $filter=Id in [1, 2, 3] MaxNodeCount = int.MaxValue; // запреты AllowedArithmeticOperators = AllowedArithmeticOperators.None; AllowedFunctions = AllowedFunctions.All | AllowedFunctions.Any; }
/// <summary> /// Initializes a new instance of the <see cref="MetadataProxy"/> class. /// </summary> /// <param name="metadataService">The metadata service.</param> /// <param name="metadataProvider">The metadata provider.</param> /// <param name="childMetadataName">Name of the child metadata.</param> public MetadataProxy( IMetadataService metadataService, IMetadataProvider metadataProvider, string childMetadataName ) { if ( metadataService == null ) { throw new ArgumentNullException ( "metadataService" ); } if ( metadataProvider == null ) { throw new ArgumentNullException ( "metadataProvider" ); } _metadataService = metadataService; _metadataProvider = metadataProvider; _childMetadataName = childMetadataName; InitializeProxy (); }
/// <summary> /// Froms the member ref signature token. /// </summary> /// <param name="provider">The provider.</param> /// <param name="token">The token.</param> /// <returns></returns> public static Signature FromMemberRefSignatureToken(ISignatureContext context, IMetadataProvider provider, TokenTypes token) { Signature result; int index = 0; byte[] buffer; provider.Read(token, out buffer); if (0x06 == buffer[0]) { result = new FieldSignature(); result.ParseSignature(context, buffer, ref index); } else { result = new MethodSignature(); result.ParseSignature(context, buffer, ref index); } Debug.Assert(index == buffer.Length, @"Not all signature bytes read."); return result; }